+2000-07-24 Elliot Lee <sopwith@redhat.com>
+ * gdk/gdkprivate.h: Remove gdk_*_lookup() defines, since they are defined by the
+ individual backends already.
+ * gdk/gdkregion-generic.h, gdk/gdktypes.h: Put gdkregionbox & gdksegment back together
+ again. Yes, there really is a good reason for this, if you are using the gdkregion
+ internals, and if you're not, why do you care?
+ * gdk/gdkwindow.c: Fix inverted condition
+ * gdk/linux-fb: Compiles (for me - it will not work elsewhere most likely).
+ * gtk/gtkcolorsel.c, gtk/gtkwindow.c: Add include for linux-fb
+ * gtk/gtkrange.c: Redraw trough when moving.
+ * gtk/gtktypeutils.c: Fix warning by adding const cast.
+ * modules/linux-fb/basic.c: Fix unknown glyph retrieval.
+
2000-07-23 Tor Lillqvist <tml@iki.fi>
* configure.in: Check for mkstemp and sigsetjmp. Output
+2000-07-24 Elliot Lee <sopwith@redhat.com>
+ * gdk/gdkprivate.h: Remove gdk_*_lookup() defines, since they are defined by the
+ individual backends already.
+ * gdk/gdkregion-generic.h, gdk/gdktypes.h: Put gdkregionbox & gdksegment back together
+ again. Yes, there really is a good reason for this, if you are using the gdkregion
+ internals, and if you're not, why do you care?
+ * gdk/gdkwindow.c: Fix inverted condition
+ * gdk/linux-fb: Compiles (for me - it will not work elsewhere most likely).
+ * gtk/gtkcolorsel.c, gtk/gtkwindow.c: Add include for linux-fb
+ * gtk/gtkrange.c: Redraw trough when moving.
+ * gtk/gtktypeutils.c: Fix warning by adding const cast.
+ * modules/linux-fb/basic.c: Fix unknown glyph retrieval.
+
2000-07-23 Tor Lillqvist <tml@iki.fi>
* configure.in: Check for mkstemp and sigsetjmp. Output
+2000-07-24 Elliot Lee <sopwith@redhat.com>
+ * gdk/gdkprivate.h: Remove gdk_*_lookup() defines, since they are defined by the
+ individual backends already.
+ * gdk/gdkregion-generic.h, gdk/gdktypes.h: Put gdkregionbox & gdksegment back together
+ again. Yes, there really is a good reason for this, if you are using the gdkregion
+ internals, and if you're not, why do you care?
+ * gdk/gdkwindow.c: Fix inverted condition
+ * gdk/linux-fb: Compiles (for me - it will not work elsewhere most likely).
+ * gtk/gtkcolorsel.c, gtk/gtkwindow.c: Add include for linux-fb
+ * gtk/gtkrange.c: Redraw trough when moving.
+ * gtk/gtktypeutils.c: Fix warning by adding const cast.
+ * modules/linux-fb/basic.c: Fix unknown glyph retrieval.
+
2000-07-23 Tor Lillqvist <tml@iki.fi>
* configure.in: Check for mkstemp and sigsetjmp. Output
+2000-07-24 Elliot Lee <sopwith@redhat.com>
+ * gdk/gdkprivate.h: Remove gdk_*_lookup() defines, since they are defined by the
+ individual backends already.
+ * gdk/gdkregion-generic.h, gdk/gdktypes.h: Put gdkregionbox & gdksegment back together
+ again. Yes, there really is a good reason for this, if you are using the gdkregion
+ internals, and if you're not, why do you care?
+ * gdk/gdkwindow.c: Fix inverted condition
+ * gdk/linux-fb: Compiles (for me - it will not work elsewhere most likely).
+ * gtk/gtkcolorsel.c, gtk/gtkwindow.c: Add include for linux-fb
+ * gtk/gtkrange.c: Redraw trough when moving.
+ * gtk/gtktypeutils.c: Fix warning by adding const cast.
+ * modules/linux-fb/basic.c: Fix unknown glyph retrieval.
+
2000-07-23 Tor Lillqvist <tml@iki.fi>
* configure.in: Check for mkstemp and sigsetjmp. Output
+2000-07-24 Elliot Lee <sopwith@redhat.com>
+ * gdk/gdkprivate.h: Remove gdk_*_lookup() defines, since they are defined by the
+ individual backends already.
+ * gdk/gdkregion-generic.h, gdk/gdktypes.h: Put gdkregionbox & gdksegment back together
+ again. Yes, there really is a good reason for this, if you are using the gdkregion
+ internals, and if you're not, why do you care?
+ * gdk/gdkwindow.c: Fix inverted condition
+ * gdk/linux-fb: Compiles (for me - it will not work elsewhere most likely).
+ * gtk/gtkcolorsel.c, gtk/gtkwindow.c: Add include for linux-fb
+ * gtk/gtkrange.c: Redraw trough when moving.
+ * gtk/gtktypeutils.c: Fix warning by adding const cast.
+ * modules/linux-fb/basic.c: Fix unknown glyph retrieval.
+
2000-07-23 Tor Lillqvist <tml@iki.fi>
* configure.in: Check for mkstemp and sigsetjmp. Output
+2000-07-24 Elliot Lee <sopwith@redhat.com>
+ * gdk/gdkprivate.h: Remove gdk_*_lookup() defines, since they are defined by the
+ individual backends already.
+ * gdk/gdkregion-generic.h, gdk/gdktypes.h: Put gdkregionbox & gdksegment back together
+ again. Yes, there really is a good reason for this, if you are using the gdkregion
+ internals, and if you're not, why do you care?
+ * gdk/gdkwindow.c: Fix inverted condition
+ * gdk/linux-fb: Compiles (for me - it will not work elsewhere most likely).
+ * gtk/gtkcolorsel.c, gtk/gtkwindow.c: Add include for linux-fb
+ * gtk/gtkrange.c: Redraw trough when moving.
+ * gtk/gtktypeutils.c: Fix warning by adding const cast.
+ * modules/linux-fb/basic.c: Fix unknown glyph retrieval.
+
2000-07-23 Tor Lillqvist <tml@iki.fi>
* configure.in: Check for mkstemp and sigsetjmp. Output
+2000-07-24 Elliot Lee <sopwith@redhat.com>
+ * gdk/gdkprivate.h: Remove gdk_*_lookup() defines, since they are defined by the
+ individual backends already.
+ * gdk/gdkregion-generic.h, gdk/gdktypes.h: Put gdkregionbox & gdksegment back together
+ again. Yes, there really is a good reason for this, if you are using the gdkregion
+ internals, and if you're not, why do you care?
+ * gdk/gdkwindow.c: Fix inverted condition
+ * gdk/linux-fb: Compiles (for me - it will not work elsewhere most likely).
+ * gtk/gtkcolorsel.c, gtk/gtkwindow.c: Add include for linux-fb
+ * gtk/gtkrange.c: Redraw trough when moving.
+ * gtk/gtktypeutils.c: Fix warning by adding const cast.
+ * modules/linux-fb/basic.c: Fix unknown glyph retrieval.
+
2000-07-23 Tor Lillqvist <tml@iki.fi>
* configure.in: Check for mkstemp and sigsetjmp. Output
-version-info $(LT_CURRENT):$(LT_REVISION):$(LT_AGE) \
-export-dynamic \
-rpath @prefix@/lib \
+ -L../gdk-pixbuf/.libs -lgdk_pixbuf \
@PANGO_LIBS@ \
@GLIB_DEPLIBS@ \
@more_ldflags@ \
#define GDK_WINDOW_TYPE(d) (((GdkWindowObject*)(GDK_WINDOW (d)))->window_type)
#define GDK_WINDOW_DESTROYED(d) (((GdkWindowObject*)(GDK_WINDOW (d)))->destroyed)
-#define gdk_window_lookup(xid) ((GdkWindow*) gdk_xid_table_lookup (xid))
-#define gdk_pixmap_lookup(xid) ((GdkPixmap*) gdk_xid_table_lookup (xid))
-#define gdk_font_lookup(xid) ((GdkFont*) gdk_xid_table_lookup (xid))
-
typedef struct _GdkColorInfo GdkColorInfo;
typedef struct _GdkFontPrivate GdkFontPrivate;
typedef struct _GdkEventFilter GdkEventFilter;
#ifndef __GDK_REGION_GENERIC_H__
#define __GDK_REGION_GENERIC_H__
-typedef struct _GdkRegionBox GdkRegionBox;
-
-struct _GdkRegionBox
-{
- int x1, x2, y1, y2;
-};
+typedef GdkSegment GdkRegionBox;
/*
* clip region
GdkWindowObject *child = tmp_list->data;
tmp_list = tmp_list->next;
- if (child->input_only)
+ if (!child->input_only)
{
gint width, height;
{
GdkDrawable parent_instance;
- gpointer user_data;
-
GdkDrawable *impl; /* window-system-specific delegate object */
GdkWindowObject *parent;
+ gpointer user_data;
+
gint x;
gint y;
. Fix CTree
. DnD?
-. All the standard X cursors
+. Fix xbm cursors (almost done, need to figure out edges thingie).
+. When cursor is changed on active window, really change the cursor
+. Faster
static gint gdk_colormap_match_color (GdkColormap *cmap,
GdkColor *color,
const gchar *available);
+
+static gpointer parent_class;
+
+static void
+gdk_colormap_finalize (GObject *object)
+{
+ GdkColormap *colormap = GDK_COLORMAP(object);
+ GdkColormapPrivateFB *private = (GdkColormapPrivateFB*) colormap;
+
+ if (private->hash)
+ g_hash_table_destroy (private->hash);
+
+ g_free (private->info);
+ g_free (colormap->colors);
+
+ G_OBJECT_CLASS(parent_class)->finalize(object);
+}
+
+static void
+gdk_colormap_init (GdkColormap *colormap)
+{
+ colormap->windowing_data = NULL;
+
+ colormap->size = 0;
+ colormap->colors = NULL;
+}
+
+static void
+gdk_colormap_class_init (GdkColormapClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+ parent_class = g_type_class_peek_parent (klass);
+
+ object_class->finalize = gdk_colormap_finalize;
+}
+
+GType
+gdk_colormap_get_type (void)
+{
+ static GType object_type = 0;
+
+ if (!object_type)
+ {
+ static const GTypeInfo object_info =
+ {
+ sizeof (GdkColormapFBClass),
+ (GBaseInitFunc) NULL,
+ (GBaseFinalizeFunc) NULL,
+ (GClassInitFunc) gdk_colormap_class_init,
+ NULL, /* class_finalize */
+ NULL, /* class_data */
+ sizeof (GdkColormapPrivateFB),
+ 0, /* n_preallocs */
+ (GInstanceInitFunc) gdk_colormap_init,
+ };
+
+ object_type = g_type_register_static (G_TYPE_OBJECT,
+ "GdkColormap",
+ &object_info);
+ }
+
+ return object_type;
+}
+
GdkColormap*
gdk_colormap_new (GdkVisual *visual,
gint private_cmap)
g_return_val_if_fail (visual != NULL, NULL);
- private = g_new (GdkColormapPrivateFB, 1);
+ private = (GdkColormapPrivateFB *)g_type_create_instance(gdk_colormap_get_type());
colormap = (GdkColormap*) private;
private->base.visual = visual;
- private->base.ref_count = 1;
fbd = gdk_display;
private->hash = NULL;
return colormap;
}
-void
-_gdk_colormap_real_destroy (GdkColormap *colormap)
-{
- GdkColormapPrivateFB *private = (GdkColormapPrivateFB*) colormap;
-
- if (private->hash)
- g_hash_table_destroy (private->hash);
-
- g_free (private->info);
- g_free (colormap->colors);
- g_free (colormap);
-}
-
#define MIN_SYNC_TIME 2
void
#include "gdkprivate-fb.h"
#include "gdkcursor.h"
-#include "/home/sopwith/bin/t.xbm"
+#include "/home/sopwith/bin/t2.xbm"
static struct {
const guchar *bits;
int width, height, hotx, hoty;
GdkPixmap *pm;
} stock_cursors[] = {
- {X_cursor_bits, 14, 14, 6, 8},
- {X_cursor_mask_bits, 16, 16, 7, 9},
- {arrow_bits, 14, 14, 13, 14},
- {arrow_mask_bits, 16, 16, 14, 15},
- {based_arrow_down_bits, 8, 10, 3, 1},
- {based_arrow_down_mask_bits, 10, 12, 4, 2},
- {based_arrow_up_bits, 8, 10, 3, 1},
- {based_arrow_up_mask_bits, 10, 12, 4, 2},
- {boat_bits, 16, 8, 14, 5},
- {boat_mask_bits, 16, 9, 14, 5},
- {bogosity_bits, 13, 14, 6, 8},
- {bogosity_mask_bits, 15, 16, 7, 9},
- {bottom_left_corner_bits, 14, 14, 0, 1},
- {bottom_left_corner_mask_bits, 16, 16, 1, 2},
- {bottom_right_corner_bits, 14, 14, 13, 1},
- {bottom_right_corner_mask_bits, 16, 16, 14, 2},
- {bottom_side_bits, 13, 14, 6, 1},
- {bottom_side_mask_bits, 15, 16, 7, 2},
- {bottom_tee_bits, 14, 10, 7, 1},
- {bottom_tee_mask_bits, 16, 12, 8, 2},
- {box_spiral_bits, 15, 16, 8, 8},
- {box_spiral_mask_bits, 16, 16, 8, 8},
- {center_ptr_bits, 10, 14, 4, 14},
- {center_ptr_mask_bits, 12, 16, 5, 15},
- {circle_bits, 14, 14, 7, 7},
- {circle_mask_bits, 16, 16, 8, 8},
- {clock_bits, 14, 16, 6, 13},
- {clock_mask_bits, 15, 16, 6, 13},
- {coffee_mug_bits, 15, 16, 7, 7},
- {coffee_mug_mask_bits, 16, 16, 7, 7},
- {cross_bits, 16, 15, 7, 8},
- {cross_mask_bits, 16, 16, 7, 9},
- {cross_reverse_bits, 16, 15, 7, 8},
- {cross_reverse_mask_bits, 16, 15, 7, 8},
- {crosshair_bits, 16, 15, 7, 8},
- {crosshair_mask_bits, 16, 16, 7, 9},
- {diamond_cross_bits, 15, 15, 7, 8},
- {diamond_cross_mask_bits, 16, 16, 7, 9},
- {dot_bits, 10, 10, 5, 5},
- {dot_mask_bits, 12, 12, 6, 6},
- {dotbox_bits, 12, 12, 6, 7},
- {dotbox_mask_bits, 14, 14, 7, 8},
- {double_arrow_bits, 10, 14, 5, 7},
- {double_arrow_mask_bits, 12, 16, 6, 8},
- {draft_large_bits, 15, 15, 14, 15},
- {draft_large_mask_bits, 15, 16, 14, 16},
- {draft_small_bits, 15, 15, 14, 15},
- {draft_small_mask_bits, 15, 15, 14, 15},
- {draped_box_bits, 12, 12, 6, 7},
- {draped_box_mask_bits, 14, 14, 7, 8},
- {exchange_bits, 14, 14, 6, 8},
- {exchange_mask_bits, 16, 16, 7, 9},
- {fleur_bits, 14, 14, 7, 7},
- {fleur_mask_bits, 16, 16, 8, 8},
- {gobbler_bits, 16, 15, 14, 13},
- {gobbler_mask_bits, 16, 16, 14, 13},
- {gumby_bits, 16, 16, 2, 16},
- {gumby_mask_bits, 16, 16, 2, 16},
- {hand1_bits, 13, 16, 12, 16},
- {hand1_mask_bits, 13, 16, 12, 16},
- {hand2_bits, 15, 14, 0, 14},
- {hand2_mask_bits, 16, 16, 0, 15},
- {heart_bits, 15, 14, 6, 6},
- {heart_mask_bits, 15, 14, 6, 6},
- {icon_bits, 16, 16, 8, 8},
- {icon_mask_bits, 16, 16, 8, 8},
- {iron_cross_bits, 14, 14, 7, 8},
- {iron_cross_mask_bits, 16, 16, 8, 9},
- {left_ptr_bits, 8, 14, 0, 14},
- {left_ptr_mask_bits, 10, 16, 1, 15},
- {left_side_bits, 14, 13, 0, 7},
- {left_side_mask_bits, 16, 15, 1, 8},
- {left_tee_bits, 10, 14, 0, 7},
- {left_tee_mask_bits, 12, 16, 1, 8},
- {leftbutton_bits, 16, 16, 8, 8},
- {leftbutton_mask_bits, 15, 16, 8, 8},
- {ll_angle_bits, 10, 10, 0, 1},
- {ll_angle_mask_bits, 12, 12, 1, 2},
- {lr_angle_bits, 10, 10, 9, 1},
- {lr_angle_mask_bits, 12, 12, 10, 2},
- {man_bits, 16, 16, 14, 11},
- {man_mask_bits, 16, 16, 14, 11},
- {middlebutton_bits, 16, 16, 8, 8},
- {middlebutton_mask_bits, 15, 16, 8, 8},
- {mouse_bits, 15, 14, 4, 13},
- {mouse_mask_bits, 16, 16, 4, 15},
- {pencil_bits, 11, 16, 10, 1},
- {pencil_mask_bits, 13, 16, 11, 1},
- {pirate_bits, 15, 16, 7, 4},
- {pirate_mask_bits, 16, 16, 7, 4},
- {plus_bits, 10, 10, 4, 5},
- {plus_mask_bits, 12, 12, 5, 6},
- {question_arrow_bits, 9, 15, 4, 8},
- {question_arrow_mask_bits, 11, 16, 5, 8},
- {right_ptr_bits, 8, 14, 7, 14},
- {right_ptr_mask_bits, 10, 16, 8, 15},
- {right_side_bits, 14, 13, 13, 7},
- {right_side_mask_bits, 16, 15, 14, 8},
- {right_tee_bits, 10, 14, 9, 7},
- {right_tee_mask_bits, 12, 16, 10, 8},
- {rightbutton_bits, 16, 16, 8, 8},
- {rightbutton_mask_bits, 15, 16, 8, 8},
- {rtl_logo_bits, 14, 14, 6, 8},
- {rtl_logo_mask_bits, 16, 16, 7, 9},
- {sailboat_bits, 12, 13, 6, 14},
- {sailboat_mask_bits, 16, 16, 8, 16},
- {sb_down_arrow_bits, 7, 15, 3, 0},
- {sb_down_arrow_mask_bits, 9, 16, 4, 1},
- {sb_h_double_arrow_bits, 15, 7, 7, 4},
- {sb_h_double_arrow_mask_bits, 15, 9, 7, 5},
- {sb_left_arrow_bits, 15, 7, -1, 4},
- {sb_left_arrow_mask_bits, 16, 9, 0, 5},
- {sb_right_arrow_bits, 15, 7, 15, 4},
- {sb_right_arrow_mask_bits, 16, 9, 15, 5},
- {sb_up_arrow_bits, 7, 15, 3, 16},
- {sb_up_arrow_mask_bits, 9, 16, 4, 16},
- {sb_v_double_arrow_bits, 7, 15, 3, 8},
- {sb_v_double_arrow_mask_bits, 9, 15, 4, 8},
- {shuttle_bits, 15, 16, 10, 16},
- {shuttle_mask_bits, 16, 16, 11, 16},
- {sizing_bits, 14, 14, 7, 7},
- {sizing_mask_bits, 16, 16, 8, 8},
- {spider_bits, 16, 16, 6, 9},
- {spider_mask_bits, 16, 16, 6, 9},
- {spraycan_bits, 11, 16, 9, 14},
- {spraycan_mask_bits, 12, 16, 10, 14},
- {star_bits, 15, 16, 7, 9},
- {star_mask_bits, 16, 16, 7, 9},
- {target_bits, 15, 13, 7, 7},
- {target_mask_bits, 16, 14, 7, 7},
- {tcross_bits, 13, 13, 6, 7},
- {tcross_mask_bits, 15, 15, 7, 8},
- {top_left_arrow_bits, 14, 14, 0, 14},
- {top_left_arrow_mask_bits, 16, 16, 1, 15},
- {top_left_corner_bits, 14, 14, 0, 14},
- {top_left_corner_mask_bits, 16, 16, 1, 15},
- {top_right_corner_bits, 14, 14, 13, 14},
- {top_right_corner_mask_bits, 16, 16, 14, 15},
- {top_side_bits, 13, 14, 6, 14},
- {top_side_mask_bits, 15, 16, 7, 15},
- {top_tee_bits, 14, 10, 7, 10},
- {top_tee_mask_bits, 16, 12, 8, 11},
- {trek_bits, 7, 16, 3, 16},
- {trek_mask_bits, 9, 16, 4, 16},
- {ul_angle_bits, 10, 10, 0, 10},
- {ul_angle_mask_bits, 12, 12, 1, 11},
- {umbrella_bits, 14, 14, 7, 12},
- {umbrella_mask_bits, 16, 16, 8, 14},
- {ur_angle_bits, 10, 10, 9, 10},
- {ur_angle_mask_bits, 12, 12, 10, 11},
- {watch_bits, 16, 16, 15, 7},
- {watch_mask_bits, 16, 16, 15, 7},
- {xterm_bits, 7, 14, 3, 7},
- {xterm_mask_bits, 9, 16, 4, 8}
+{X_cursor_bits, X_cursor_width, X_cursor_height, X_cursor_x_hot, X_cursor_y_hot},
+{X_cursor_mask_bits, X_cursor_mask_width, X_cursor_mask_height, X_cursor_mask_x_hot, X_cursor_mask_y_hot},
+{arrow_bits, arrow_width, arrow_height, arrow_x_hot, arrow_y_hot},
+{arrow_mask_bits, arrow_mask_width, arrow_mask_height, arrow_mask_x_hot, arrow_mask_y_hot},
+{based_arrow_down_bits, based_arrow_down_width, based_arrow_down_height, based_arrow_down_x_hot, based_arrow_down_y_hot},
+{based_arrow_down_mask_bits, based_arrow_down_mask_width, based_arrow_down_mask_height, based_arrow_down_mask_x_hot, based_arrow_down_mask_y_hot},
+{based_arrow_up_bits, based_arrow_up_width, based_arrow_up_height, based_arrow_up_x_hot, based_arrow_up_y_hot},
+{based_arrow_up_mask_bits, based_arrow_up_mask_width, based_arrow_up_mask_height, based_arrow_up_mask_x_hot, based_arrow_up_mask_y_hot},
+{boat_bits, boat_width, boat_height, boat_x_hot, boat_y_hot},
+{boat_mask_bits, boat_mask_width, boat_mask_height, boat_mask_x_hot, boat_mask_y_hot},
+{bogosity_bits, bogosity_width, bogosity_height, bogosity_x_hot, bogosity_y_hot},
+{bogosity_mask_bits, bogosity_mask_width, bogosity_mask_height, bogosity_mask_x_hot, bogosity_mask_y_hot},
+{bottom_left_corner_bits, bottom_left_corner_width, bottom_left_corner_height, bottom_left_corner_x_hot, bottom_left_corner_y_hot},
+{bottom_left_corner_mask_bits, bottom_left_corner_mask_width, bottom_left_corner_mask_height, bottom_left_corner_mask_x_hot, bottom_left_corner_mask_y_hot},
+{bottom_right_corner_bits, bottom_right_corner_width, bottom_right_corner_height, bottom_right_corner_x_hot, bottom_right_corner_y_hot},
+{bottom_right_corner_mask_bits, bottom_right_corner_mask_width, bottom_right_corner_mask_height, bottom_right_corner_mask_x_hot, bottom_right_corner_mask_y_hot},
+{bottom_side_bits, bottom_side_width, bottom_side_height, bottom_side_x_hot, bottom_side_y_hot},
+{bottom_side_mask_bits, bottom_side_mask_width, bottom_side_mask_height, bottom_side_mask_x_hot, bottom_side_mask_y_hot},
+{bottom_tee_bits, bottom_tee_width, bottom_tee_height, bottom_tee_x_hot, bottom_tee_y_hot},
+{bottom_tee_mask_bits, bottom_tee_mask_width, bottom_tee_mask_height, bottom_tee_mask_x_hot, bottom_tee_mask_y_hot},
+{box_spiral_bits, box_spiral_width, box_spiral_height, box_spiral_x_hot, box_spiral_y_hot},
+{box_spiral_mask_bits, box_spiral_mask_width, box_spiral_mask_height, box_spiral_mask_x_hot, box_spiral_mask_y_hot},
+{center_ptr_bits, center_ptr_width, center_ptr_height, center_ptr_x_hot, center_ptr_y_hot},
+{center_ptr_mask_bits, center_ptr_mask_width, center_ptr_mask_height, center_ptr_mask_x_hot, center_ptr_mask_y_hot},
+{circle_bits, circle_width, circle_height, circle_x_hot, circle_y_hot},
+{circle_mask_bits, circle_mask_width, circle_mask_height, circle_mask_x_hot, circle_mask_y_hot},
+{clock_bits, clock_width, clock_height, clock_x_hot, clock_y_hot},
+{clock_mask_bits, clock_mask_width, clock_mask_height, clock_mask_x_hot, clock_mask_y_hot},
+{coffee_mug_bits, coffee_mug_width, coffee_mug_height, coffee_mug_x_hot, coffee_mug_y_hot},
+{coffee_mug_mask_bits, coffee_mug_mask_width, coffee_mug_mask_height, coffee_mug_mask_x_hot, coffee_mug_mask_y_hot},
+{cross_bits, cross_width, cross_height, cross_x_hot, cross_y_hot},
+{cross_mask_bits, cross_mask_width, cross_mask_height, cross_mask_x_hot, cross_mask_y_hot},
+{cross_reverse_bits, cross_reverse_width, cross_reverse_height, cross_reverse_x_hot, cross_reverse_y_hot},
+{cross_reverse_mask_bits, cross_reverse_mask_width, cross_reverse_mask_height, cross_reverse_mask_x_hot, cross_reverse_mask_y_hot},
+{crosshair_bits, crosshair_width, crosshair_height, crosshair_x_hot, crosshair_y_hot},
+{crosshair_mask_bits, crosshair_mask_width, crosshair_mask_height, crosshair_mask_x_hot, crosshair_mask_y_hot},
+{diamond_cross_bits, diamond_cross_width, diamond_cross_height, diamond_cross_x_hot, diamond_cross_y_hot},
+{diamond_cross_mask_bits, diamond_cross_mask_width, diamond_cross_mask_height, diamond_cross_mask_x_hot, diamond_cross_mask_y_hot},
+{dot_bits, dot_width, dot_height, dot_x_hot, dot_y_hot},
+{dot_mask_bits, dot_mask_width, dot_mask_height, dot_mask_x_hot, dot_mask_y_hot},
+{dotbox_bits, dotbox_width, dotbox_height, dotbox_x_hot, dotbox_y_hot},
+{dotbox_mask_bits, dotbox_mask_width, dotbox_mask_height, dotbox_mask_x_hot, dotbox_mask_y_hot},
+{double_arrow_bits, double_arrow_width, double_arrow_height, double_arrow_x_hot, double_arrow_y_hot},
+{double_arrow_mask_bits, double_arrow_mask_width, double_arrow_mask_height, double_arrow_mask_x_hot, double_arrow_mask_y_hot},
+{draft_large_bits, draft_large_width, draft_large_height, draft_large_x_hot, draft_large_y_hot},
+{draft_large_mask_bits, draft_large_mask_width, draft_large_mask_height, draft_large_mask_x_hot, draft_large_mask_y_hot},
+{draft_small_bits, draft_small_width, draft_small_height, draft_small_x_hot, draft_small_y_hot},
+{draft_small_mask_bits, draft_small_mask_width, draft_small_mask_height, draft_small_mask_x_hot, draft_small_mask_y_hot},
+{draped_box_bits, draped_box_width, draped_box_height, draped_box_x_hot, draped_box_y_hot},
+{draped_box_mask_bits, draped_box_mask_width, draped_box_mask_height, draped_box_mask_x_hot, draped_box_mask_y_hot},
+{exchange_bits, exchange_width, exchange_height, exchange_x_hot, exchange_y_hot},
+{exchange_mask_bits, exchange_mask_width, exchange_mask_height, exchange_mask_x_hot, exchange_mask_y_hot},
+{fleur_bits, fleur_width, fleur_height, fleur_x_hot, fleur_y_hot},
+{fleur_mask_bits, fleur_mask_width, fleur_mask_height, fleur_mask_x_hot, fleur_mask_y_hot},
+{gobbler_bits, gobbler_width, gobbler_height, gobbler_x_hot, gobbler_y_hot},
+{gobbler_mask_bits, gobbler_mask_width, gobbler_mask_height, gobbler_mask_x_hot, gobbler_mask_y_hot},
+{gumby_bits, gumby_width, gumby_height, gumby_x_hot, gumby_y_hot},
+{gumby_mask_bits, gumby_mask_width, gumby_mask_height, gumby_mask_x_hot, gumby_mask_y_hot},
+{hand1_bits, hand1_width, hand1_height, hand1_x_hot, hand1_y_hot},
+{hand1_mask_bits, hand1_mask_width, hand1_mask_height, hand1_mask_x_hot, hand1_mask_y_hot},
+{hand2_bits, hand2_width, hand2_height, hand2_x_hot, hand2_y_hot},
+{hand2_mask_bits, hand2_mask_width, hand2_mask_height, hand2_mask_x_hot, hand2_mask_y_hot},
+{heart_bits, heart_width, heart_height, heart_x_hot, heart_y_hot},
+{heart_mask_bits, heart_mask_width, heart_mask_height, heart_mask_x_hot, heart_mask_y_hot},
+{icon_bits, icon_width, icon_height, icon_x_hot, icon_y_hot},
+{icon_mask_bits, icon_mask_width, icon_mask_height, icon_mask_x_hot, icon_mask_y_hot},
+{iron_cross_bits, iron_cross_width, iron_cross_height, iron_cross_x_hot, iron_cross_y_hot},
+{iron_cross_mask_bits, iron_cross_mask_width, iron_cross_mask_height, iron_cross_mask_x_hot, iron_cross_mask_y_hot},
+{left_ptr_bits, left_ptr_width, left_ptr_height, left_ptr_x_hot, left_ptr_y_hot},
+{left_ptr_mask_bits, left_ptr_mask_width, left_ptr_mask_height, left_ptr_mask_x_hot, left_ptr_mask_y_hot},
+{left_side_bits, left_side_width, left_side_height, left_side_x_hot, left_side_y_hot},
+{left_side_mask_bits, left_side_mask_width, left_side_mask_height, left_side_mask_x_hot, left_side_mask_y_hot},
+{left_tee_bits, left_tee_width, left_tee_height, left_tee_x_hot, left_tee_y_hot},
+{left_tee_mask_bits, left_tee_mask_width, left_tee_mask_height, left_tee_mask_x_hot, left_tee_mask_y_hot},
+{leftbutton_bits, leftbutton_width, leftbutton_height, leftbutton_x_hot, leftbutton_y_hot},
+{leftbutton_mask_bits, leftbutton_mask_width, leftbutton_mask_height, leftbutton_mask_x_hot, leftbutton_mask_y_hot},
+{ll_angle_bits, ll_angle_width, ll_angle_height, ll_angle_x_hot, ll_angle_y_hot},
+{ll_angle_mask_bits, ll_angle_mask_width, ll_angle_mask_height, ll_angle_mask_x_hot, ll_angle_mask_y_hot},
+{lr_angle_bits, lr_angle_width, lr_angle_height, lr_angle_x_hot, lr_angle_y_hot},
+{lr_angle_mask_bits, lr_angle_mask_width, lr_angle_mask_height, lr_angle_mask_x_hot, lr_angle_mask_y_hot},
+{man_bits, man_width, man_height, man_x_hot, man_y_hot},
+{man_mask_bits, man_mask_width, man_mask_height, man_mask_x_hot, man_mask_y_hot},
+{middlebutton_bits, middlebutton_width, middlebutton_height, middlebutton_x_hot, middlebutton_y_hot},
+{middlebutton_mask_bits, middlebutton_mask_width, middlebutton_mask_height, middlebutton_mask_x_hot, middlebutton_mask_y_hot},
+{mouse_bits, mouse_width, mouse_height, mouse_x_hot, mouse_y_hot},
+{mouse_mask_bits, mouse_mask_width, mouse_mask_height, mouse_mask_x_hot, mouse_mask_y_hot},
+{pencil_bits, pencil_width, pencil_height, pencil_x_hot, pencil_y_hot},
+{pencil_mask_bits, pencil_mask_width, pencil_mask_height, pencil_mask_x_hot, pencil_mask_y_hot},
+{pirate_bits, pirate_width, pirate_height, pirate_x_hot, pirate_y_hot},
+{pirate_mask_bits, pirate_mask_width, pirate_mask_height, pirate_mask_x_hot, pirate_mask_y_hot},
+{plus_bits, plus_width, plus_height, plus_x_hot, plus_y_hot},
+{plus_mask_bits, plus_mask_width, plus_mask_height, plus_mask_x_hot, plus_mask_y_hot},
+{question_arrow_bits, question_arrow_width, question_arrow_height, question_arrow_x_hot, question_arrow_y_hot},
+{question_arrow_mask_bits, question_arrow_mask_width, question_arrow_mask_height, question_arrow_mask_x_hot, question_arrow_mask_y_hot},
+{right_ptr_bits, right_ptr_width, right_ptr_height, right_ptr_x_hot, right_ptr_y_hot},
+{right_ptr_mask_bits, right_ptr_mask_width, right_ptr_mask_height, right_ptr_mask_x_hot, right_ptr_mask_y_hot},
+{right_side_bits, right_side_width, right_side_height, right_side_x_hot, right_side_y_hot},
+{right_side_mask_bits, right_side_mask_width, right_side_mask_height, right_side_mask_x_hot, right_side_mask_y_hot},
+{right_tee_bits, right_tee_width, right_tee_height, right_tee_x_hot, right_tee_y_hot},
+{right_tee_mask_bits, right_tee_mask_width, right_tee_mask_height, right_tee_mask_x_hot, right_tee_mask_y_hot},
+{rightbutton_bits, rightbutton_width, rightbutton_height, rightbutton_x_hot, rightbutton_y_hot},
+{rightbutton_mask_bits, rightbutton_mask_width, rightbutton_mask_height, rightbutton_mask_x_hot, rightbutton_mask_y_hot},
+{rtl_logo_bits, rtl_logo_width, rtl_logo_height, rtl_logo_x_hot, rtl_logo_y_hot},
+{rtl_logo_mask_bits, rtl_logo_mask_width, rtl_logo_mask_height, rtl_logo_mask_x_hot, rtl_logo_mask_y_hot},
+{sailboat_bits, sailboat_width, sailboat_height, sailboat_x_hot, sailboat_y_hot},
+{sailboat_mask_bits, sailboat_mask_width, sailboat_mask_height, sailboat_mask_x_hot, sailboat_mask_y_hot},
+{sb_down_arrow_bits, sb_down_arrow_width, sb_down_arrow_height, sb_down_arrow_x_hot, sb_down_arrow_y_hot},
+{sb_down_arrow_mask_bits, sb_down_arrow_mask_width, sb_down_arrow_mask_height, sb_down_arrow_mask_x_hot, sb_down_arrow_mask_y_hot},
+{sb_h_double_arrow_bits, sb_h_double_arrow_width, sb_h_double_arrow_height, sb_h_double_arrow_x_hot, sb_h_double_arrow_y_hot},
+{sb_h_double_arrow_mask_bits, sb_h_double_arrow_mask_width, sb_h_double_arrow_mask_height, sb_h_double_arrow_mask_x_hot, sb_h_double_arrow_mask_y_hot},
+{sb_left_arrow_bits, sb_left_arrow_width, sb_left_arrow_height, sb_left_arrow_x_hot, sb_left_arrow_y_hot},
+{sb_left_arrow_mask_bits, sb_left_arrow_mask_width, sb_left_arrow_mask_height, sb_left_arrow_mask_x_hot, sb_left_arrow_mask_y_hot},
+{sb_right_arrow_bits, sb_right_arrow_width, sb_right_arrow_height, sb_right_arrow_x_hot, sb_right_arrow_y_hot},
+{sb_right_arrow_mask_bits, sb_right_arrow_mask_width, sb_right_arrow_mask_height, sb_right_arrow_mask_x_hot, sb_right_arrow_mask_y_hot},
+{sb_up_arrow_bits, sb_up_arrow_width, sb_up_arrow_height, sb_up_arrow_x_hot, sb_up_arrow_y_hot},
+{sb_up_arrow_mask_bits, sb_up_arrow_mask_width, sb_up_arrow_mask_height, sb_up_arrow_mask_x_hot, sb_up_arrow_mask_y_hot},
+{sb_v_double_arrow_bits, sb_v_double_arrow_width, sb_v_double_arrow_height, sb_v_double_arrow_x_hot, sb_v_double_arrow_y_hot},
+{sb_v_double_arrow_mask_bits, sb_v_double_arrow_mask_width, sb_v_double_arrow_mask_height, sb_v_double_arrow_mask_x_hot, sb_v_double_arrow_mask_y_hot},
+{shuttle_bits, shuttle_width, shuttle_height, shuttle_x_hot, shuttle_y_hot},
+{shuttle_mask_bits, shuttle_mask_width, shuttle_mask_height, shuttle_mask_x_hot, shuttle_mask_y_hot},
+{sizing_bits, sizing_width, sizing_height, sizing_x_hot, sizing_y_hot},
+{sizing_mask_bits, sizing_mask_width, sizing_mask_height, sizing_mask_x_hot, sizing_mask_y_hot},
+{spider_bits, spider_width, spider_height, spider_x_hot, spider_y_hot},
+{spider_mask_bits, spider_mask_width, spider_mask_height, spider_mask_x_hot, spider_mask_y_hot},
+{spraycan_bits, spraycan_width, spraycan_height, spraycan_x_hot, spraycan_y_hot},
+{spraycan_mask_bits, spraycan_mask_width, spraycan_mask_height, spraycan_mask_x_hot, spraycan_mask_y_hot},
+{star_bits, star_width, star_height, star_x_hot, star_y_hot},
+{star_mask_bits, star_mask_width, star_mask_height, star_mask_x_hot, star_mask_y_hot},
+{target_bits, target_width, target_height, target_x_hot, target_y_hot},
+{target_mask_bits, target_mask_width, target_mask_height, target_mask_x_hot, target_mask_y_hot},
+{tcross_bits, tcross_width, tcross_height, tcross_x_hot, tcross_y_hot},
+{tcross_mask_bits, tcross_mask_width, tcross_mask_height, tcross_mask_x_hot, tcross_mask_y_hot},
+{top_left_arrow_bits, top_left_arrow_width, top_left_arrow_height, top_left_arrow_x_hot, top_left_arrow_y_hot},
+{top_left_arrow_mask_bits, top_left_arrow_mask_width, top_left_arrow_mask_height, top_left_arrow_mask_x_hot, top_left_arrow_mask_y_hot},
+{top_left_corner_bits, top_left_corner_width, top_left_corner_height, top_left_corner_x_hot, top_left_corner_y_hot},
+{top_left_corner_mask_bits, top_left_corner_mask_width, top_left_corner_mask_height, top_left_corner_mask_x_hot, top_left_corner_mask_y_hot},
+{top_right_corner_bits, top_right_corner_width, top_right_corner_height, top_right_corner_x_hot, top_right_corner_y_hot},
+{top_right_corner_mask_bits, top_right_corner_mask_width, top_right_corner_mask_height, top_right_corner_mask_x_hot, top_right_corner_mask_y_hot},
+{top_side_bits, top_side_width, top_side_height, top_side_x_hot, top_side_y_hot},
+{top_side_mask_bits, top_side_mask_width, top_side_mask_height, top_side_mask_x_hot, top_side_mask_y_hot},
+{top_tee_bits, top_tee_width, top_tee_height, top_tee_x_hot, top_tee_y_hot},
+{top_tee_mask_bits, top_tee_mask_width, top_tee_mask_height, top_tee_mask_x_hot, top_tee_mask_y_hot},
+{trek_bits, trek_width, trek_height, trek_x_hot, trek_y_hot},
+{trek_mask_bits, trek_mask_width, trek_mask_height, trek_mask_x_hot, trek_mask_y_hot},
+{ul_angle_bits, ul_angle_width, ul_angle_height, ul_angle_x_hot, ul_angle_y_hot},
+{ul_angle_mask_bits, ul_angle_mask_width, ul_angle_mask_height, ul_angle_mask_x_hot, ul_angle_mask_y_hot},
+{umbrella_bits, umbrella_width, umbrella_height, umbrella_x_hot, umbrella_y_hot},
+{umbrella_mask_bits, umbrella_mask_width, umbrella_mask_height, umbrella_mask_x_hot, umbrella_mask_y_hot},
+{ur_angle_bits, ur_angle_width, ur_angle_height, ur_angle_x_hot, ur_angle_y_hot},
+{ur_angle_mask_bits, ur_angle_mask_width, ur_angle_mask_height, ur_angle_mask_x_hot, ur_angle_mask_y_hot},
+{watch_bits, watch_width, watch_height, watch_x_hot, watch_y_hot},
+{watch_mask_bits, watch_mask_width, watch_mask_height, watch_mask_x_hot, watch_mask_y_hot},
+{xterm_bits, xterm_width, xterm_height, xterm_x_hot, xterm_y_hot},
+{xterm_mask_bits, xterm_mask_width, xterm_mask_height, xterm_mask_x_hot, xterm_mask_y_hot}
};
+
+
+GdkCursor*
+_gdk_cursor_new_from_pixmap (GdkPixmap *source,
+ GdkPixmap *mask,
+ GdkColor *fg,
+ GdkColor *bg,
+ gint x,
+ gint y,
+ gint mask_off_x,
+ gint mask_off_y)
+{
+ GdkCursorPrivateFB *private;
+ GdkCursor *cursor;
+
+ g_return_val_if_fail (source != NULL, NULL);
+
+ private = g_new (GdkCursorPrivateFB, 1);
+ cursor = (GdkCursor *) private;
+ cursor->type = GDK_CURSOR_IS_PIXMAP;
+ cursor->ref_count = 1;
+ private->cursor = gdk_pixmap_ref(source);
+ private->mask = gdk_pixmap_ref(mask);
+ private->hot_x = x;
+ private->hot_y = y;
+ private->mask_off_x = mask_off_x;
+ private->mask_off_y = mask_off_y;
+
+ return cursor;
+}
+
GdkCursor*
gdk_cursor_new (GdkCursorType cursor_type)
{
gdk_pixmap_ref(mask);
}
- return gdk_cursor_new_from_pixmap(pm, mask, NULL, NULL,
- stock_cursors[cursor_type].hotx,
- stock_cursors[cursor_type].hoty);
+ return _gdk_cursor_new_from_pixmap(pm, mask, NULL, NULL,
+ stock_cursors[cursor_type].hotx,
+ stock_cursors[cursor_type].hoty,
+ (stock_cursors[cursor_type].hotx - stock_cursors[cursor_type+1].hotx) * 1,
+ (stock_cursors[cursor_type].hoty - stock_cursors[cursor_type+1].hoty) * 1);
}
GdkCursor*
gint x,
gint y)
{
- GdkCursorPrivateFB *private;
- GdkCursor *cursor;
-
- g_return_val_if_fail (source != NULL, NULL);
-
- private = g_new (GdkCursorPrivateFB, 1);
- cursor = (GdkCursor *) private;
- cursor->type = GDK_CURSOR_IS_PIXMAP;
- cursor->ref_count = 1;
- private->cursor = gdk_pixmap_ref(source);
- private->mask = gdk_pixmap_ref(mask);
- private->hot_x = x;
- private->hot_y = y;
-
- return cursor;
+ return _gdk_cursor_new_from_pixmap(source, mask, fg, bg, x, y, 0, 0);
}
void
/* Drag Contexts */
static GList *contexts;
+static gpointer parent_class = NULL;
-GdkDragContext *
-gdk_drag_context_new (void)
+
+static void
+gdk_drag_context_init (GdkDragContext *dragcontext)
{
- GdkDragContextPrivate *result;
+ dragcontext->windowing_data = NULL;
- result = g_new0 (GdkDragContextPrivate, 1);
+ contexts = g_list_prepend (contexts, dragcontext);
+}
- result->ref_count = 1;
+static void
+gdk_drag_context_finalize (GObject *object)
+{
+ GdkDragContext *context = GDK_DRAG_CONTEXT (object);
+
+ g_list_free (context->targets);
- contexts = g_list_prepend (contexts, result);
+ if (context->source_window)
+ {
+ gdk_window_unref (context->source_window);
+ }
+
+ if (context->dest_window)
+ gdk_window_unref (context->dest_window);
+
+ contexts = g_list_remove (contexts, context);
- return (GdkDragContext *)result;
+ G_OBJECT_CLASS (parent_class)->finalize (object);
}
-void
-gdk_drag_context_ref (GdkDragContext *context)
+static void
+gdk_drag_context_class_init (GdkDragContextClass *klass)
{
- g_return_if_fail (context != NULL);
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+ parent_class = g_type_class_peek_parent (klass);
- ((GdkDragContextPrivate *)context)->ref_count++;
+ object_class->finalize = gdk_drag_context_finalize;
}
-void
-gdk_drag_context_unref (GdkDragContext *context)
-{
- GdkDragContextPrivate *private = (GdkDragContextPrivate *)context;
- g_return_if_fail (context != NULL);
- g_return_if_fail (private->ref_count > 0);
+GType
+gdk_drag_context_get_type (void)
+{
+ static GType object_type = 0;
- private->ref_count--;
-
- if (private->ref_count == 0)
+ if (!object_type)
{
- g_dataset_destroy (private);
+ static const GTypeInfo object_info =
+ {
+ sizeof (GdkDragContextClass),
+ (GBaseInitFunc) NULL,
+ (GBaseFinalizeFunc) NULL,
+ (GClassInitFunc) gdk_drag_context_class_init,
+ NULL, /* class_finalize */
+ NULL, /* class_data */
+ sizeof (GdkDragContext),
+ 0, /* n_preallocs */
+ (GInstanceInitFunc) gdk_drag_context_init,
+ };
- g_list_free (context->targets);
-
- if (context->source_window)
- {
-#if 0
- if ((context->protocol == GDK_DRAG_PROTO_XDND) &&
- !context->is_source)
- xdnd_manage_source_filter (context, context->source_window, FALSE);
-#endif
-
- gdk_window_unref (context->source_window);
- }
+ object_type = g_type_register_static (G_TYPE_OBJECT,
+ "GdkDragContext",
+ &object_info);
+ }
+
+ return object_type;
+}
- if (context->dest_window)
- gdk_window_unref (context->dest_window);
+GdkDragContext *
+gdk_drag_context_new (void)
+{
+ return (GdkDragContext *)g_type_create_instance(gdk_drag_context_get_type());
+}
-#if 0
- if (private->window_cache)
- gdk_window_cache_destroy (private->window_cache);
-#endif
+void
+gdk_drag_context_ref (GdkDragContext *context)
+{
+ g_object_ref(G_OBJECT(context));
+}
- contexts = g_list_remove (contexts, private);
- g_free (private);
- }
+void
+gdk_drag_context_unref (GdkDragContext *context)
+{
+ g_object_unref(G_OBJECT(context));
}
/*************************************************************
#include "gdkprivate-fb.h"
#include "mi.h"
-/* #define USE_FTGRAYS */
-#define USE_AA
#include <freetype/ftglyph.h>
+#include <string.h>
#include <endian.h>
#ifndef __BYTE_ORDER
#error "endian.h needs to #define __BYTE_ORDER"
#endif
static void gdk_fb_drawable_set_pixel(GdkDrawable *drawable, GdkGC *gc, int x, int y, GdkColor *spot, gboolean abs_coords);
+typedef enum { GPR_USED_BG, GPR_AA_GRAYVAL, GPR_NONE, GPR_ERR_BOUNDS } GetPixelRet;
+static GetPixelRet gdk_fb_drawable_get_pixel(GdkDrawable *drawable, GdkGC *gc, int x, int y, GdkColor *spot,
+ gboolean abs_coords, GdkDrawable *bg_relto, GdkDrawable *bgpm);
-static void gdk_fb_drawable_destroy (GdkDrawable *drawable);
void gdk_fb_draw_rectangle (GdkDrawable *drawable,
GdkGC *gc,
gint filled,
gint ydest,
gint width,
gint height);
+static void gdk_fb_draw_image(GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkImage *image,
+ gint xsrc,
+ gint ysrc,
+ gint xdest,
+ gint ydest,
+ gint width,
+ gint height);
static void gdk_fb_draw_points (GdkDrawable *drawable,
GdkGC *gc,
GdkPoint *points,
GdkGC *gc,
GdkPoint *points,
gint npoints);
+static GdkColormap* gdk_fb_get_colormap (GdkDrawable *drawable);
+static void gdk_fb_set_colormap (GdkDrawable *drawable,
+ GdkColormap *colormap);
+
+static gpointer parent_class = NULL;
+
+static void
+gdk_fb_get_size(GdkDrawable *d, gint *width, gint *height)
+{
+ if(width)
+ *width = GDK_DRAWABLE_P(d)->width;
+ if(height)
+ *height = GDK_DRAWABLE_P(d)->height;
+}
+
+static void
+gdk_drawable_impl_fb_class_init (GdkDrawableFBClass *klass)
+{
+ GdkDrawableClass *drawable_class = GDK_DRAWABLE_CLASS (klass);
+
+ parent_class = g_type_class_peek_parent (klass);
+
+ drawable_class->create_gc = _gdk_fb_gc_new;
+ drawable_class->draw_rectangle = gdk_fb_draw_rectangle;
+ drawable_class->draw_arc = gdk_fb_draw_arc;
+ drawable_class->draw_polygon = gdk_fb_draw_polygon;
+ drawable_class->draw_text = gdk_fb_draw_text;
+ drawable_class->draw_text_wc = gdk_fb_draw_text_wc;
+ drawable_class->draw_drawable = gdk_fb_draw_drawable;
+ drawable_class->draw_points = gdk_fb_draw_points;
+ drawable_class->draw_segments = gdk_fb_draw_segments;
+ drawable_class->draw_lines = gdk_fb_draw_lines;
+ drawable_class->draw_glyphs = gdk_fb_draw_glyphs;
+ drawable_class->draw_image = gdk_fb_draw_image;
+
+ drawable_class->set_colormap = gdk_fb_set_colormap;
+ drawable_class->get_colormap = gdk_fb_get_colormap;
+ drawable_class->get_size = gdk_fb_get_size;
+}
+
+GType
+gdk_drawable_impl_fb_get_type (void)
+{
+ static GType object_type = 0;
-GdkDrawableClass _gdk_fb_drawable_class = {
- gdk_fb_drawable_destroy,
- (gpointer)_gdk_fb_gc_new,
- gdk_fb_draw_rectangle,
- gdk_fb_draw_arc,
- gdk_fb_draw_polygon,
- gdk_fb_draw_text,
- gdk_fb_draw_text_wc,
- gdk_fb_draw_drawable,
- gdk_fb_draw_points,
- gdk_fb_draw_segments,
- gdk_fb_draw_lines,
- gdk_fb_draw_glyphs
-};
+ if (!object_type)
+ {
+ static const GTypeInfo object_info =
+ {
+ sizeof (GdkDrawableFBClass),
+ (GBaseInitFunc) NULL,
+ (GBaseFinalizeFunc) NULL,
+ (GClassInitFunc) gdk_drawable_impl_fb_class_init,
+ NULL, /* class_finalize */
+ NULL, /* class_data */
+ sizeof (GdkDrawableFBData),
+ 0, /* n_preallocs */
+ (GInstanceInitFunc) NULL,
+ };
+
+ object_type = g_type_register_static (GDK_TYPE_DRAWABLE,
+ "GdkDrawableFB",
+ &object_info);
+ }
+
+ return object_type;
+}
/*****************************************************
* FB specific implementations of generic functions *
*****************************************************/
-GdkColormap*
-gdk_drawable_get_colormap (GdkDrawable *drawable)
+static GdkColormap*
+gdk_fb_get_colormap (GdkDrawable *drawable)
{
- GdkColormap *retval = GDK_DRAWABLE_P(drawable)->colormap;
+ GdkColormap *retval = GDK_DRAWABLE_FBDATA(drawable)->colormap;
if(!retval)
retval = gdk_colormap_get_system();
return retval;
}
-void
-gdk_drawable_set_colormap (GdkDrawable *drawable,
- GdkColormap *colormap)
+static void
+gdk_fb_set_colormap (GdkDrawable *drawable,
+ GdkColormap *colormap)
{
GdkColormap *old_cmap;
- old_cmap = GDK_DRAWABLE_P(drawable)->colormap;
- GDK_DRAWABLE_P(drawable)->colormap = gdk_colormap_ref(colormap);
+ old_cmap = GDK_DRAWABLE_FBDATA(drawable)->colormap;
+ GDK_DRAWABLE_FBDATA(drawable)->colormap = gdk_colormap_ref(colormap);
gdk_colormap_unref(old_cmap);
}
/* Drawing
*/
-static void
-gdk_fb_drawable_destroy (GdkDrawable *drawable)
-{
-}
-
-static GdkRegion *
-gdk_fb_clip_region(GdkDrawable *drawable, GdkGC *gc, gboolean do_clipping)
+GdkRegion *
+gdk_fb_clip_region(GdkDrawable *drawable, GdkGC *gc, gboolean do_clipping, gboolean do_children)
{
GdkRectangle draw_rect;
GdkRegion *real_clip_region, *tmpreg;
+ gboolean watchit = FALSE;
- g_assert(!GDK_IS_WINDOW(drawable) || !GDK_WINDOW_P(drawable)->input_only);
+ g_assert(!GDK_IS_WINDOW(GDK_DRAWABLE_P(drawable)->wrapper) || !GDK_WINDOW_P(GDK_DRAWABLE_P(drawable)->wrapper)->input_only);
draw_rect.x = GDK_DRAWABLE_FBDATA(drawable)->llim_x;
draw_rect.y = GDK_DRAWABLE_FBDATA(drawable)->llim_y;
draw_rect.height = GDK_DRAWABLE_FBDATA(drawable)->lim_y - draw_rect.y;
real_clip_region = gdk_region_rectangle(&draw_rect);
- if(do_clipping && GDK_IS_WINDOW(drawable) && GDK_WINDOW_P(drawable)->mapped && !GDK_WINDOW_P(drawable)->input_only)
+ if(do_clipping && GDK_IS_WINDOW(GDK_DRAWABLE_FBDATA(drawable)->wrapper) && GDK_WINDOW_P(GDK_DRAWABLE_P(drawable)->wrapper)->mapped && !GDK_WINDOW_P(GDK_DRAWABLE_FBDATA(drawable)->wrapper)->input_only)
{
GdkWindow *parentwin, *lastwin;
- for(parentwin = lastwin = ((GdkWindow *)drawable);
- parentwin; lastwin = parentwin, parentwin = GDK_WINDOW_P(parentwin)->parent)
+ lastwin = GDK_DRAWABLE_FBDATA(drawable)->wrapper;
+ if(do_children)
+ parentwin = lastwin;
+ else
+ parentwin = (GdkWindow *)GDK_WINDOW_P(lastwin)->parent;
+
+ for(;
+ parentwin; lastwin = parentwin, parentwin = (GdkWindow *)GDK_WINDOW_P(parentwin)->parent)
{
GList *cur;
for(cur = GDK_WINDOW_P(parentwin)->children; cur && cur->data != lastwin; cur = cur->next)
{
+ GdkRegion *reg2;
+
if(!GDK_WINDOW_P(cur->data)->mapped || GDK_WINDOW_P(cur->data)->input_only)
continue;
- draw_rect.x = GDK_DRAWABLE_FBDATA(cur->data)->llim_x;
- draw_rect.y = GDK_DRAWABLE_FBDATA(cur->data)->llim_y;
- draw_rect.width = GDK_DRAWABLE_FBDATA(cur->data)->lim_x - draw_rect.x;
- draw_rect.height = GDK_DRAWABLE_FBDATA(cur->data)->lim_y - draw_rect.y;
+
+ draw_rect.x = GDK_DRAWABLE_IMPL_FBDATA(cur->data)->llim_x;
+ draw_rect.y = GDK_DRAWABLE_IMPL_FBDATA(cur->data)->llim_y;
+ draw_rect.width = GDK_DRAWABLE_IMPL_FBDATA(cur->data)->lim_x - draw_rect.x;
+ draw_rect.height = GDK_DRAWABLE_IMPL_FBDATA(cur->data)->lim_y - draw_rect.y;
tmpreg = gdk_region_rectangle(&draw_rect);
- gdk_region_subtract(real_clip_region, tmpreg);
+
+ reg2 = gdk_region_copy(real_clip_region);
+ gdk_region_subtract(reg2, tmpreg);
+ if(watchit && !gdk_region_point_in(reg2, 100, 353))
+ G_BREAKPOINT();
+ gdk_region_destroy(real_clip_region); real_clip_region = reg2;
gdk_region_destroy(tmpreg);
}
}
{
GdkDrawable *cmask = GDK_GC_FBDATA(gc)->values.clip_mask;
- g_assert(GDK_DRAWABLE_P(cmask)->depth == 1);
- g_assert(GDK_DRAWABLE_FBDATA(cmask)->abs_x == 0
- && GDK_DRAWABLE_FBDATA(cmask)->abs_y == 0);
+ g_assert(GDK_DRAWABLE_IMPL_FBDATA(cmask)->depth == 1);
+ g_assert(GDK_DRAWABLE_IMPL_FBDATA(cmask)->abs_x == 0
+ && GDK_DRAWABLE_IMPL_FBDATA(cmask)->abs_y == 0);
- draw_rect.x = GDK_DRAWABLE_FBDATA(drawable)->abs_x + GDK_DRAWABLE_FBDATA(cmask)->llim_x + GDK_GC_FBDATA(gc)->values.clip_x_origin;
- draw_rect.y = GDK_DRAWABLE_FBDATA(drawable)->abs_y + GDK_DRAWABLE_FBDATA(cmask)->llim_y + GDK_GC_FBDATA(gc)->values.clip_y_origin;
- draw_rect.width = GDK_DRAWABLE_P(cmask)->width;
- draw_rect.height = GDK_DRAWABLE_P(cmask)->height;
+ draw_rect.x = GDK_DRAWABLE_FBDATA(drawable)->abs_x + GDK_DRAWABLE_IMPL_FBDATA(cmask)->llim_x + GDK_GC_FBDATA(gc)->values.clip_x_origin;
+ draw_rect.y = GDK_DRAWABLE_FBDATA(drawable)->abs_y + GDK_DRAWABLE_IMPL_FBDATA(cmask)->llim_y + GDK_GC_FBDATA(gc)->values.clip_y_origin;
+ draw_rect.width = GDK_DRAWABLE_IMPL_FBDATA(cmask)->width;
+ draw_rect.height = GDK_DRAWABLE_IMPL_FBDATA(cmask)->height;
tmpreg = gdk_region_rectangle(&draw_rect);
gdk_region_intersect(real_clip_region, tmpreg);
gdk_region_destroy(tmpreg);
+ if(!real_clip_region->numRects)
+ g_warning("Empty clip region");
}
}
if(gc
&& (GDK_GC_FBDATA(gc)->values.clip_mask
|| GDK_GC_FBDATA(gc)->values.tile
- || GDK_GC_FBDATA(gc)->values.stipple))
+ || GDK_GC_FBDATA(gc)->values.stipple
+ || GDK_GC_FBDATA(gc)->values.function == GDK_INVERT))
{
int clipxoff, clipyoff; /* Amounts to add to curx & cury to get x & y in clip mask */
int tsxoff, tsyoff;
guint mask_rowstride;
GdkPixmap *ts = NULL;
gboolean solid_stipple;
+ GdkFunction func = GDK_GC_FBDATA(gc)->values.function;
cmask = GDK_GC_FBDATA(gc)->values.clip_mask;
if(cmask)
{
- clipmem = GDK_DRAWABLE_FBDATA(cmask)->mem;
- clipxoff = GDK_DRAWABLE_FBDATA(cmask)->abs_x - GDK_GC_FBDATA(gc)->values.clip_x_origin - GDK_DRAWABLE_FBDATA(drawable)->abs_x;
- clipyoff = GDK_DRAWABLE_FBDATA(cmask)->abs_y - GDK_GC_FBDATA(gc)->values.clip_y_origin - GDK_DRAWABLE_FBDATA(drawable)->abs_y;
- mask_rowstride = GDK_DRAWABLE_FBDATA(cmask)->rowstride;
+ clipmem = GDK_DRAWABLE_IMPL_FBDATA(cmask)->mem;
+ clipxoff = GDK_DRAWABLE_IMPL_FBDATA(cmask)->abs_x - GDK_GC_FBDATA(gc)->values.clip_x_origin - GDK_DRAWABLE_FBDATA(drawable)->abs_x;
+ clipyoff = GDK_DRAWABLE_IMPL_FBDATA(cmask)->abs_y - GDK_GC_FBDATA(gc)->values.clip_y_origin - GDK_DRAWABLE_FBDATA(drawable)->abs_y;
+ mask_rowstride = GDK_DRAWABLE_IMPL_FBDATA(cmask)->rowstride;
}
if(GDK_GC_FBDATA(gc)->values.fill == GDK_TILED
int drawh;
rely = cury - GDK_DRAWABLE_FBDATA(drawable)->abs_y;
- drawh = (rely + GDK_GC_FBDATA(gc)->values.ts_y_origin) % GDK_DRAWABLE_P(ts)->height;
+ drawh = (rely + GDK_GC_FBDATA(gc)->values.ts_y_origin) % GDK_DRAWABLE_IMPL_FBDATA(ts)->height;
if(drawh < 0)
drawh += GDK_DRAWABLE_P(ts)->height;
- ystep = MIN(GDK_DRAWABLE_P(ts)->height - drawh, cur->y2 - rely);
+ ystep = MIN(GDK_DRAWABLE_IMPL_FBDATA(ts)->height - drawh, cur->y2 - rely);
for(curx = cur->x1; curx < cur->x2; curx += xstep)
{
relx = curx - GDK_DRAWABLE_FBDATA(drawable)->abs_x;
- draww = (relx + GDK_GC_FBDATA(gc)->values.ts_x_origin) % GDK_DRAWABLE_P(ts)->width;
+ draww = (relx + GDK_GC_FBDATA(gc)->values.ts_x_origin) % GDK_DRAWABLE_IMPL_FBDATA(ts)->width;
if(draww < 0)
- draww += GDK_DRAWABLE_P(ts)->width;
+ draww += GDK_DRAWABLE_IMPL_FBDATA(ts)->width;
- xstep = MIN(GDK_DRAWABLE_P(ts)->width - draww, cur->x2 - relx);
+ xstep = MIN(GDK_DRAWABLE_IMPL_FBDATA(ts)->width - draww, cur->x2 - relx);
- gdk_fb_draw_drawable_3(drawable, gc, ts,
+ gdk_fb_draw_drawable_3(drawable, gc, GDK_DRAWABLE_IMPL(ts),
dc,
draww, drawh,
relx, rely,
continue;
}
- if(ts)
+ if(func == GDK_INVERT)
{
- int wid = GDK_DRAWABLE_P(ts)->width, hih = GDK_DRAWABLE_P(ts)->height;
+ gdk_fb_drawable_get_pixel(drawable, gc, curx, cury, &spot, TRUE, NULL, NULL);
+ spot.pixel = ~spot.pixel;
+ spot.red = ~spot.red;
+ spot.green = ~spot.green;
+ spot.blue = ~spot.blue;
+ }
+ else if(ts)
+ {
+ int wid = GDK_DRAWABLE_IMPL_FBDATA(ts)->width, hih = GDK_DRAWABLE_IMPL_FBDATA(ts)->height;
maskx = (curx+tsxoff)%wid;
masky = (cury+tsyoff)%hih;
if(masky < 0)
masky += hih;
- foo = GDK_DRAWABLE_FBDATA(ts)->mem[(maskx >> 3) + GDK_DRAWABLE_FBDATA(ts)->rowstride*masky];
+ foo = GDK_DRAWABLE_IMPL_FBDATA(ts)->mem[(maskx >> 3) + GDK_DRAWABLE_IMPL_FBDATA(ts)->rowstride*masky];
if(foo & (1 << (maskx % 8)))
{
spot = GDK_GC_FBDATA(gc)->values.foreground;
}
void
-gdk_fb_fill_spans(GdkDrawable *drawable,
+gdk_fb_fill_spans(GdkDrawable *real_drawable,
GdkGC *gc,
GdkRectangle *rects, int nrects)
{
int i;
GdkColor color;
GdkRegion *real_clip_region, *tmpreg;
- GdkRectangle draw_rect, cursor_rect;
+ GdkRectangle draw_rect;
GdkVisual *visual = gdk_visual_get_system();
gboolean handle_cursor = FALSE;
+ GdkDrawable *drawable;
+
+ drawable = real_drawable;
- if(GDK_IS_WINDOW(drawable) && !GDK_WINDOW_P(drawable)->mapped)
+ GDK_CHECK_IMPL(drawable);
+
+ if(GDK_IS_WINDOW(GDK_DRAWABLE_P(drawable)->wrapper) && !GDK_WINDOW_P(GDK_DRAWABLE_P(drawable)->wrapper)->mapped)
return;
- if(GDK_IS_WINDOW(drawable) && GDK_WINDOW_P(drawable)->input_only)
+ if(GDK_IS_WINDOW(GDK_DRAWABLE_P(drawable)->wrapper) && GDK_WINDOW_P(GDK_DRAWABLE_P(drawable)->wrapper)->input_only)
g_error("Drawing on the evil input-only!");
if(gc && (GDK_GC_FBDATA(gc)->values_mask | GDK_GC_FOREGROUND))
color = GDK_GC_FBDATA(gc)->values.foreground;
- else if(GDK_IS_WINDOW(drawable))
- color = GDK_WINDOW_P(drawable)->bg_color;
+ else if(GDK_IS_WINDOW(GDK_DRAWABLE_P(drawable)->wrapper))
+ color = GDK_WINDOW_P(GDK_DRAWABLE_P(drawable)->wrapper)->bg_color;
else
gdk_color_black(GDK_DRAWABLE_P(drawable)->colormap, &color);
- real_clip_region = gdk_fb_clip_region(drawable, gc, TRUE);
+ real_clip_region = gdk_fb_clip_region(drawable, gc, TRUE, (!gc || GDK_GC_FBDATA(gc)->values.function!=GDK_INVERT));
- gdk_fb_get_cursor_rect(&cursor_rect);
- if(GDK_DRAWABLE_FBDATA(drawable)->mem == GDK_DRAWABLE_FBDATA(gdk_parent_root)->mem
- && cursor_rect.x >= 0
- && gdk_region_rect_in(real_clip_region, &cursor_rect) != GDK_OVERLAP_RECTANGLE_OUT)
+ if(GDK_DRAWABLE_FBDATA(drawable)->mem == GDK_DRAWABLE_IMPL_FBDATA(gdk_parent_root)->mem
+ && gdk_fb_cursor_region_need_hide(real_clip_region))
{
handle_cursor = TRUE;
gdk_fb_cursor_hide();
gdk_fb_cursor_unhide();
}
-typedef enum { GPR_USED_BG, GPR_AA_GRAYVAL, GPR_NONE, GPR_ERR_BOUNDS } GetPixelRet;
static GetPixelRet
gdk_fb_drawable_get_pixel(GdkDrawable *drawable, GdkGC *gc, int x, int y, GdkColor *spot,
gboolean abs_coords, GdkDrawable *bg_relto, GdkDrawable *bgpm)
{
int bgx, bgy;
- bgx = (x - GDK_DRAWABLE_FBDATA(bg_relto)->abs_x) % GDK_DRAWABLE_P(bgpm)->width;
- bgy = (y - GDK_DRAWABLE_FBDATA(bg_relto)->abs_y) % GDK_DRAWABLE_P(bgpm)->height;
+ bgx = (x - GDK_DRAWABLE_IMPL_FBDATA(bg_relto)->abs_x) % GDK_DRAWABLE_IMPL_FBDATA(bgpm)->width;
+ bgy = (y - GDK_DRAWABLE_IMPL_FBDATA(bg_relto)->abs_y) % GDK_DRAWABLE_IMPL_FBDATA(bgpm)->height;
gdk_fb_drawable_get_pixel(bgpm, gc, bgx, bgy, spot, FALSE, NULL, NULL);
retval = GPR_USED_BG;
dc->rowstride = GDK_DRAWABLE_FBDATA(drawable)->rowstride;
dc->handle_cursor = FALSE;
dc->bgpm = NULL;
- dc->bg_relto = drawable;
+ dc->bg_relto = GDK_DRAWABLE_P(drawable)->wrapper;
dc->draw_bg = draw_bg;
- if(GDK_IS_WINDOW(drawable))
+ GDK_CHECK_IMPL(drawable);
+
+ if(GDK_IS_WINDOW(GDK_DRAWABLE_P(drawable)->wrapper))
{
- dc->bgpm = GDK_WINDOW_P(drawable)->bg_pixmap;
+ dc->bgpm = GDK_WINDOW_P(GDK_DRAWABLE_P(drawable)->wrapper)->bg_pixmap;
if(dc->bgpm == GDK_PARENT_RELATIVE_BG)
{
- for(; dc->bgpm == GDK_PARENT_RELATIVE_BG && dc->bg_relto; dc->bg_relto = GDK_WINDOW_P(dc->bg_relto)->parent)
+ for(; dc->bgpm == GDK_PARENT_RELATIVE_BG && dc->bg_relto; dc->bg_relto = (GdkWindow *)GDK_WINDOW_P(dc->bg_relto)->parent)
dc->bgpm = GDK_WINDOW_P(dc->bg_relto)->bg_pixmap;
}
dc->clipxoff = - GDK_DRAWABLE_FBDATA(drawable)->abs_x;
dc->clipyoff = - GDK_DRAWABLE_FBDATA(drawable)->abs_y;
- dc->real_clip_region = gdk_fb_clip_region(drawable, gc, do_clipping);
+ dc->real_clip_region = gdk_fb_clip_region(drawable, gc, do_clipping, TRUE);
if(gc)
{
if(GDK_GC_FBDATA(gc)->values.clip_mask)
{
- dc->clipmem = GDK_DRAWABLE_FBDATA(GDK_GC_FBDATA(gc)->values.clip_mask)->mem;
- dc->clip_rowstride = GDK_DRAWABLE_FBDATA(GDK_GC_FBDATA(gc)->values.clip_mask)->rowstride;
+ dc->clipmem = GDK_DRAWABLE_IMPL_FBDATA(GDK_GC_FBDATA(gc)->values.clip_mask)->mem;
+ dc->clip_rowstride = GDK_DRAWABLE_IMPL_FBDATA(GDK_GC_FBDATA(gc)->values.clip_mask)->rowstride;
}
}
- if(do_clipping)
+ if(do_clipping
+ && GDK_DRAWABLE_FBDATA(drawable)->mem == GDK_DRAWABLE_IMPL_FBDATA(gdk_parent_root)->mem
+ && gdk_fb_cursor_region_need_hide(dc->real_clip_region))
{
- GdkRectangle cursor_rect;
-
- gdk_fb_get_cursor_rect(&cursor_rect);
-
- if(GDK_DRAWABLE_FBDATA(drawable)->mem == GDK_DRAWABLE_FBDATA(gdk_parent_root)->mem
- && cursor_rect.x >= 0
- && gdk_region_rect_in(dc->real_clip_region, &cursor_rect) != GDK_OVERLAP_RECTANGLE_OUT)
- {
- dc->handle_cursor = TRUE;
- gdk_fb_cursor_hide();
- }
+ dc->handle_cursor = TRUE;
+ gdk_fb_cursor_hide();
}
}
int src_x_off, src_y_off;
GdkRegion *tmpreg, *real_clip_region;
int i;
+ int draw_direction = 1;
+ gboolean do_quick_draw;
- if(GDK_IS_WINDOW(drawable))
+ GDK_CHECK_IMPL(drawable);
+
+ if(GDK_IS_WINDOW(GDK_DRAWABLE_P(drawable)->wrapper))
{
- if(!GDK_WINDOW_P(drawable)->mapped)
+ if(!GDK_WINDOW_P(GDK_DRAWABLE_P(drawable)->wrapper)->mapped)
return;
- if(GDK_WINDOW_P(drawable)->input_only)
+ if(GDK_WINDOW_P(GDK_DRAWABLE_P(drawable)->wrapper)->input_only)
g_error("Drawing on the evil input-only!");
}
if(drawable == src)
{
- GdkDrawableFBData *fbd = GDK_DRAWABLE_FBDATA(src);
+ GdkRegionBox srcb, destb;
+ srcb.x1 = xsrc;
+ srcb.y1 = ysrc;
+ srcb.x2 = xsrc + width;
+ srcb.y2 = ysrc + height;
+ destb.x1 = xdest;
+ destb.y1 = ydest;
+ destb.x2 = xdest + width;
+ destb.y2 = xdest + height;
+
+ if(EXTENTCHECK(&srcb, &destb)
+ && ydest > ysrc)
+ draw_direction = -1;
+#if 0
+ {
+ GdkDrawableFBData *fbd = GDK_DRAWABLE_FBDATA(src);
- /* One lame hack deserves another ;-) */
- srcmem = g_alloca(fbd->rowstride * fbd->lim_y);
- memcpy(srcmem, dc->mem, fbd->rowstride * fbd->lim_y);
+ /* One lame hack deserves another ;-) */
+ srcmem = g_alloca(fbd->rowstride * (fbd->lim_y - fbd->llim_y));
+ memmove(srcmem, dc->mem + (fbd->rowstride * fbd->llim_y), fbd->rowstride * (fbd->lim_y - fbd->llim_y));
+ srcmem -= (fbd->rowstride * fbd->llim_y);
+ }
+#endif
}
/* Do some magic to avoid creating extra regions unnecessarily */
src_x_off = (GDK_DRAWABLE_FBDATA(src)->abs_x + xsrc) - (GDK_DRAWABLE_FBDATA(drawable)->abs_x + xdest);
src_y_off = (GDK_DRAWABLE_FBDATA(src)->abs_y + ysrc) - (GDK_DRAWABLE_FBDATA(drawable)->abs_y + ydest);
+ do_quick_draw = GDK_DRAWABLE_P(src)->depth == GDK_DRAWABLE_P(drawable)->depth
+ && GDK_DRAWABLE_P(src)->depth >= 8
+ && GDK_DRAWABLE_P(src)->depth <= 32
+ && (!gc || !GDK_GC_FBDATA(gc)->values.clip_mask);
+
for(i = 0; i < real_clip_region->numRects; i++)
{
GdkRegionBox *cur = &real_clip_region->rects[i];
- int cur_y;
+ int start_y, end_y, cur_y;
- if(GDK_DRAWABLE_P(src)->depth == GDK_DRAWABLE_P(drawable)->depth
- && GDK_DRAWABLE_P(src)->depth >= 8
- && GDK_DRAWABLE_P(src)->depth <= 32
- && (!gc || !GDK_GC_FBDATA(gc)->values.clip_mask))
+ if(draw_direction > 0)
+ {
+ start_y = cur->y1;
+ end_y = cur->y2;
+ }
+ else
+ {
+ start_y = cur->y2 - 1;
+ end_y = cur->y1 - 1;
+ }
+
+ if(do_quick_draw)
{
guint depth = GDK_DRAWABLE_P(src)->depth;
guint src_rowstride = GDK_DRAWABLE_FBDATA(src)->rowstride;
int linelen = (cur->x2 - cur->x1)*(depth>>3);
- for(cur_y = cur->y1; cur_y < cur->y2; cur_y++)
+ for(cur_y = start_y; cur_y*draw_direction < end_y*draw_direction; cur_y += draw_direction)
{
- memcpy(dc->mem + (cur_y * dc->rowstride) + cur->x1*(depth>>3),
- srcmem + ((cur_y + src_y_off)*src_rowstride) + (cur->x1 + src_x_off)*(depth>>3),
- linelen);
+ memmove(dc->mem + (cur_y * dc->rowstride) + cur->x1*(depth>>3),
+ srcmem + ((cur_y + src_y_off)*src_rowstride) + (cur->x1 + src_x_off)*(depth>>3),
+ linelen);
}
}
else
{
int cur_x;
- for(cur_y = cur->y1; cur_y < cur->y2; cur_y++)
+ for(cur_y = start_y; cur_y*draw_direction < end_y*draw_direction; cur_y+=draw_direction)
{
for(cur_x = cur->x1; cur_x < cur->x2; cur_x++)
{
gint width,
gint height)
{
- gdk_fb_draw_drawable_2(drawable, gc, src, xsrc, ysrc, xdest, ydest, width, height, TRUE, TRUE);
+ gdk_fb_draw_drawable_2(drawable, gc, GDK_DRAWABLE_IMPL(src), xsrc, ysrc, xdest, ydest, width, height, TRUE, TRUE);
}
static void
gint width,
gint height);
- _gdk_windowing_window_clear_area(d, 0, 0, GDK_DRAWABLE_P(d)->width, GDK_DRAWABLE_P(d)->height);
+ _gdk_windowing_window_clear_area(d, 0, 0, GDK_DRAWABLE_IMPL_FBDATA(d)->width, GDK_DRAWABLE_IMPL_FBDATA(d)->height);
}
extern FT_Library gdk_fb_ft_lib;
PangoGlyphString *glyphs)
{
int i;
- GdkPixmapFBData fbd;
- GdkDrawablePrivate tmp_foo;
- FT_Face ftf;
int xpos;
GdkFBDrawingContext fbdc;
gdk_fb_drawing_context_init(&fbdc, drawable, gc, FALSE, TRUE);
- ftf = PANGO_FB_FONT(font)->ftf;
-
/* Fake its existence as a pixmap */
- memset(&tmp_foo, 0, sizeof(tmp_foo));
- memset(&fbd, 0, sizeof(fbd));
- tmp_foo.klass = &_gdk_fb_drawable_class;
- tmp_foo.klass_data = &fbd;
- tmp_foo.window_type = GDK_DRAWABLE_PIXMAP;
pango_fb_font_set_size(font);
for(i = xpos = 0; i < glyphs->num_glyphs; i++)
{
- FT_GlyphSlot g;
- FT_Bitmap *renderme;
+ PangoFBGlyphInfo *pgi;
int this_wid;
- FT_Load_Glyph(ftf, glyphs->glyphs[i].glyph, FT_LOAD_DEFAULT);
- g = ftf->glyph;
-
- if(g->format != ft_glyph_format_bitmap)
- {
- FT_BitmapGlyph bgy;
- int bdepth;
-#ifdef USE_AA
-#ifdef USE_FTGRAYS
- bdepth = 256;
-#else
- bdepth = 128;
-#endif
-#else
- bdepth = 0;
-#endif
-
- if(FT_Get_Glyph_Bitmap(ftf, glyphs->glyphs[i].glyph, 0, bdepth, NULL, &bgy))
- continue;
-
- renderme = &bgy->bitmap;
- }
- else
- renderme = &g->bitmap;
-
- fbd.drawable_data.mem = renderme->buffer;
- fbd.drawable_data.rowstride = renderme->pitch;
- tmp_foo.width = fbd.drawable_data.lim_x = renderme->width;
- tmp_foo.height = fbd.drawable_data.lim_y = renderme->rows;
-
- switch(renderme->pixel_mode)
- {
- case ft_pixel_mode_mono:
- tmp_foo.depth = 1;
- break;
- case ft_pixel_mode_grays:
-#if defined(USE_FTGRAYS)
- tmp_foo.depth = 78;
-#else
- tmp_foo.depth = 77;
-#endif
- break;
- default:
- g_assert_not_reached();
- break;
- }
+ pgi = pango_fb_font_get_glyph_info(font, glyphs->glyphs[i].glyph);
this_wid = (xpos + glyphs->glyphs[i].geometry.width)/PANGO_SCALE;
- gdk_fb_draw_drawable_3(drawable, gc, (GdkDrawable *)&tmp_foo,
+ gdk_fb_draw_drawable_3(drawable, gc, (GdkPixmap *)&pgi->fbd,
&fbdc,
0, 0,
x + (xpos + glyphs->glyphs[i].geometry.x_offset)/PANGO_SCALE,
y + glyphs->glyphs[i].geometry.y_offset / PANGO_SCALE
- + ((-ftf->glyph->metrics.horiBearingY) >> 6),
- this_wid, renderme->rows);
+ + pgi->hbearing,
+ this_wid, pgi->fbd.drawable_data.height);
xpos += glyphs->glyphs[i].geometry.width;
}
gdk_fb_drawing_context_finalize(&fbdc);
}
+
+
+static void
+gdk_fb_draw_image(GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkImage *image,
+ gint xsrc,
+ gint ysrc,
+ gint xdest,
+ gint ydest,
+ gint width,
+ gint height)
+{
+ GdkImagePrivateFB *image_private;
+ GdkPixmapFBData fbd;
+
+ g_return_if_fail (drawable != NULL);
+ g_return_if_fail (image != NULL);
+ g_return_if_fail (gc != NULL);
+
+ image_private = (GdkImagePrivateFB*) image;
+
+ g_return_if_fail (image->type == GDK_IMAGE_NORMAL);
+
+ /* Fake its existence as a pixmap */
+ memset(&fbd, 0, sizeof(fbd));
+ fbd.drawable_data.mem = image->mem;
+ fbd.drawable_data.rowstride = image->bpl;
+ fbd.drawable_data.width = fbd.drawable_data.lim_x = image->width;
+ fbd.drawable_data.height = fbd.drawable_data.lim_y = image->height;
+ fbd.drawable_data.depth = image->depth;
+ fbd.drawable_data.window_type = GDK_DRAWABLE_PIXMAP;
+
+ gdk_fb_draw_drawable_2(drawable, gc, (GdkPixmap *)&fbd, xsrc, ysrc, xdest, ydest, width, height, TRUE, TRUE);
+}
NULL
};
- g_source_add(G_PRIORITY_HIGH_IDLE, TRUE, &fb_events_funcs, NULL, NULL, NULL);
+ g_source_add(GDK_PRIORITY_EVENTS, TRUE, &fb_events_funcs, NULL, NULL, NULL);
}
/*
{
if(event->type == GDK_EXPOSE
&& event->expose.window == gdk_parent_root)
- gdk_fb_drawable_clear(event->expose.window);
+ gdk_window_clear_area(event->expose.window, event->expose.area.x, event->expose.area.y, event->expose.area.width,
+ event->expose.area.height);
+
else if(gdk_event_func)
(*gdk_event_func)(event, gdk_event_data);
extern const char *gdk_progclass;
-#define gdk_window_lookup(xid) (xid)
-#define gdk_pixmap_lookup(xid) (xid)
-#define gdk_font_lookup(xid) (xid)
#define gdk_window_foreign_new(xid) gdk_window_ref(xid)
+#define gdk_window_lookup(xid) ((GdkWindow*) (xid))
+#define gdk_pixmap_lookup(xid) ((GdkPixmap*) (xid))
+#define gdk_font_lookup(xid) ((GdkFont*) (xid))
+
#endif /* GDKFB_H */
GDK_GC_DIRTY_TS = 1 << 1
} GdkGCDirtyValues;
-static void gdk_fb_gc_destroy (GdkGC *gc);
+static void gdk_fb_gc_finalize (GObject *obj);
static void gdk_fb_gc_get_values (GdkGC *gc,
GdkGCValues *values);
static void gdk_fb_gc_set_values (GdkGC *gc,
GdkGCValuesMask values_mask);
static void gdk_fb_gc_set_dashes (GdkGC *gc,
gint dash_offset,
- gchar dash_list[],
+ gint8 dash_list[],
gint n);
-static GdkGCClass gdk_fb_gc_class = {
- gdk_fb_gc_destroy,
- gdk_fb_gc_get_values,
- gdk_fb_gc_set_values,
- gdk_fb_gc_set_dashes
-};
+static gpointer parent_class = NULL;
+
+static void
+gdk_gc_fb_class_init (GdkGCFBClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+ GdkGCClass *gc_class = GDK_GC_CLASS (klass);
+
+ parent_class = g_type_class_peek_parent (klass);
+
+ object_class->finalize = gdk_fb_gc_finalize;
+
+ gc_class->get_values = gdk_fb_gc_get_values;
+ gc_class->set_values = gdk_fb_gc_set_values;
+ gc_class->set_dashes = gdk_fb_gc_set_dashes;
+}
+
+GType gdk_gc_fb_get_type (void)
+{
+ static GType object_type = 0;
+
+ if (!object_type)
+ {
+ static const GTypeInfo object_info =
+ {
+ sizeof (GdkGCFBClass),
+ (GBaseInitFunc) NULL,
+ (GBaseFinalizeFunc) NULL,
+ (GClassInitFunc) gdk_gc_fb_class_init,
+ NULL, /* class_finalize */
+ NULL, /* class_data */
+ sizeof (GdkGCFBData),
+ 0, /* n_preallocs */
+ (GInstanceInitFunc) NULL,
+ };
+
+ object_type = g_type_register_static (GDK_TYPE_GC,
+ "GdkGCFB",
+ &object_info);
+ }
+
+ return object_type;
+}
GdkGC *
_gdk_fb_gc_new (GdkDrawable *drawable,
GdkGCValuesMask values_mask)
{
GdkGC *gc;
- GdkGCPrivate *private;
+ GdkGC *private;
GdkGCFBData *data;
- gc = gdk_gc_alloc ();
- private = (GdkGCPrivate *)gc;
+ gc = GDK_GC(g_type_create_instance(gdk_gc_fb_get_type()));
+ private = (GdkGC *)gc;
- private->klass = &gdk_fb_gc_class;
- private->klass_data = data = g_new0 (GdkGCFBData, 1);
+ data = (GdkGCFBData *)gc;
data->values.foreground.pixel = 255;
data->values.foreground.red = data->values.foreground.green = data->values.foreground.blue = 65535;
}
static void
-gdk_fb_gc_destroy (GdkGC *gc)
+gdk_fb_gc_finalize (GObject *obj)
{
+ GdkGC *gc = GDK_GC_P(obj);
+
if (GDK_GC_FBDATA (gc)->clip_region)
gdk_region_destroy (GDK_GC_FBDATA (gc)->clip_region);
-
- g_free (GDK_GC_FBDATA (gc));
+ if (GDK_GC_FBDATA (gc)->values.clip_mask)
+ gdk_pixmap_unref(GDK_GC_FBDATA (gc)->values.clip_mask);
+ if (GDK_GC_FBDATA (gc)->values.stipple)
+ gdk_pixmap_unref(GDK_GC_FBDATA (gc)->values.stipple);
+ if (GDK_GC_FBDATA (gc)->values.tile)
+ gdk_pixmap_unref(GDK_GC_FBDATA (gc)->values.tile);
}
static void
{
oldpm = GDK_GC_FBDATA(gc)->values.tile;
if(values->tile)
- g_assert(GDK_DRAWABLE_P(values->tile)->depth >= 8);
+ g_assert(GDK_DRAWABLE_IMPL_FBDATA(values->tile)->depth >= 8);
GDK_GC_FBDATA(gc)->values.tile = values->tile?gdk_pixmap_ref(values->tile):NULL;
GDK_GC_FBDATA(gc)->values_mask |= GDK_GC_TILE;
{
oldpm = GDK_GC_FBDATA(gc)->values.stipple;
if(values->stipple)
- g_assert(GDK_DRAWABLE_P(values->stipple)->depth == 1);
+ g_assert(GDK_DRAWABLE_IMPL_FBDATA(values->stipple)->depth == 1);
GDK_GC_FBDATA(gc)->values.stipple = values->stipple?gdk_pixmap_ref(values->stipple):NULL;
GDK_GC_FBDATA(gc)->values_mask |= GDK_GC_STIPPLE;
if(oldpm)
static void
gdk_fb_gc_set_dashes (GdkGC *gc,
gint dash_offset,
- gchar dash_list[],
+ gint8 dash_list[],
gint n)
{
GDK_GC_FBDATA(gc)->dash_offset = dash_offset;
static void
gc_unset_cmask(GdkGC *gc)
{
- GdkGCPrivate *private = (GdkGCPrivate *)gc;
GdkGCFBData *data;
data = GDK_GC_FBDATA (gc);
if(data->values.clip_mask)
gdk_gc_set_clip_rectangle (GdkGC *gc,
GdkRectangle *rectangle)
{
- GdkGCPrivate *private = (GdkGCPrivate *)gc;
+ GdkGC *private = (GdkGC *)gc;
GdkGCFBData *data;
g_return_if_fail (gc != NULL);
gdk_gc_set_clip_region (GdkGC *gc,
GdkRegion *region)
{
- GdkGCPrivate *private = (GdkGCPrivate *)gc;
+ GdkGC *private = (GdkGC *)gc;
GdkGCFBData *data;
g_return_if_fail (gc != NULL);
gint dx,
gint dy)
{
- GdkWindowPrivate *private = GDK_WINDOW_P(window);
+ GdkWindowObject *private = GDK_WINDOW_P(window);
GdkRegion *invalidate_region;
GdkRectangle dest_rect;
GdkRectangle clip_rect;
GList *tmp_list;
+ gboolean handle_cursor;
g_return_if_fail (window != NULL);
g_return_if_fail (GDK_IS_WINDOW (window));
- if (GDK_DRAWABLE_DESTROYED (window))
- return;
-
- clip_rect.x = GDK_DRAWABLE_FBDATA(window)->llim_x - GDK_DRAWABLE_FBDATA(window)->abs_x;
- clip_rect.y = GDK_DRAWABLE_FBDATA(window)->llim_y - GDK_DRAWABLE_FBDATA(window)->abs_y;
- clip_rect.width = GDK_DRAWABLE_FBDATA(window)->lim_x - GDK_DRAWABLE_FBDATA(window)->llim_x;
- clip_rect.height = GDK_DRAWABLE_FBDATA(window)->lim_y - GDK_DRAWABLE_FBDATA(window)->llim_y;
+ clip_rect.x = GDK_DRAWABLE_IMPL_FBDATA(window)->llim_x;
+ clip_rect.y = GDK_DRAWABLE_IMPL_FBDATA(window)->llim_y;
+ clip_rect.width = GDK_DRAWABLE_IMPL_FBDATA(window)->lim_x - GDK_DRAWABLE_IMPL_FBDATA(window)->llim_x;
+ clip_rect.height = GDK_DRAWABLE_IMPL_FBDATA(window)->lim_y - GDK_DRAWABLE_IMPL_FBDATA(window)->llim_y;
+ handle_cursor = gdk_fb_cursor_need_hide(&clip_rect);
+ clip_rect.x -= GDK_DRAWABLE_IMPL_FBDATA(window)->abs_x;
+ clip_rect.y -= GDK_DRAWABLE_IMPL_FBDATA(window)->abs_y;
invalidate_region = gdk_region_rectangle (&clip_rect);
dest_rect = clip_rect;
dest_rect.y += dy;
gdk_rectangle_intersect (&dest_rect, &clip_rect, &dest_rect);
+ if(handle_cursor)
+ gdk_fb_cursor_hide();
+
if (dest_rect.width > 0 && dest_rect.height > 0)
{
GdkRegion *tmp_region;
tmp_region = gdk_region_rectangle (&dest_rect);
gdk_region_subtract (invalidate_region, tmp_region);
gdk_region_destroy (tmp_region);
-
- gdk_fb_draw_drawable_2(window, NULL, window, dest_rect.x - dx, dest_rect.y - dy, dest_rect.x, dest_rect.y,
+
+ gdk_fb_draw_drawable_2(GDK_DRAWABLE_IMPL(window), NULL, GDK_DRAWABLE_IMPL(window), dest_rect.x - dx, dest_rect.y - dy, dest_rect.x, dest_rect.y,
dest_rect.width, dest_rect.height,
FALSE, FALSE);
}
-
gdk_window_invalidate_region (window, invalidate_region, TRUE);
gdk_region_destroy (invalidate_region);
for(tmp_list = private->children; tmp_list; tmp_list = tmp_list->next)
- gdk_window_move (tmp_list->data, GDK_WINDOW_P(tmp_list->data)->x + dx, GDK_WINDOW_P(tmp_list->data)->y + dy);
+ gdk_fb_window_move_resize (tmp_list->data,
+ GDK_WINDOW_OBJECT(tmp_list->data)->x + dx, GDK_WINDOW_OBJECT(tmp_list->data)->y + dy,
+ GDK_DRAWABLE_IMPL_FBDATA(tmp_list->data)->width,
+ GDK_DRAWABLE_IMPL_FBDATA(tmp_list->data)->height,
+ FALSE);
+
+ if(handle_cursor)
+ gdk_fb_cursor_unhide();
}
#include "gdkprivate.h"
#include "gdkprivate-fb.h"
-struct _GdkImagePrivateFB
+static gpointer parent_class = NULL;
+
+void _gdk_windowing_image_init(void)
+{
+}
+
+static void
+gdk_image_init (GdkImage *image)
+{
+}
+
+static void
+gdk_image_finalize (GObject *object)
{
- GdkImagePrivate base;
-};
-
-static void gdk_fb_image_destroy (GdkImage *image);
-static void gdk_image_put_normal (GdkImage *image,
- GdkDrawable *drawable,
- GdkGC *gc,
- gint xsrc,
- gint ysrc,
- gint xdest,
- gint ydest,
- gint width,
- gint height);
-
-static GdkImageClass image_class_normal = {
- gdk_fb_image_destroy,
- gdk_image_put_normal
-};
+ GdkImage *image = GDK_IMAGE (object);
+
+ GdkImagePrivateFB *private;
+
+ private = (GdkImagePrivateFB*) image;
+
+ g_free(image->mem); image->mem = NULL;
+
+ G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static void
+gdk_image_class_init (GdkImageClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+ parent_class = g_type_class_peek_parent (klass);
+
+ object_class->finalize = gdk_image_finalize;
+}
+
+GType
+gdk_image_get_type (void)
+{
+ static GType object_type = 0;
+
+ if (!object_type)
+ {
+ static const GTypeInfo object_info =
+ {
+ sizeof (GdkImageClass),
+ (GBaseInitFunc) NULL,
+ (GBaseFinalizeFunc) NULL,
+ (GClassInitFunc) gdk_image_class_init,
+ NULL, /* class_finalize */
+ NULL, /* class_data */
+ sizeof (GdkImage),
+ 0, /* n_preallocs */
+ (GInstanceInitFunc) gdk_image_init,
+ };
+
+ object_type = g_type_register_static (G_TYPE_OBJECT,
+ "GdkImage",
+ &object_info);
+ }
+
+ return object_type;
+}
GdkImage *
gdk_image_new_bitmap(GdkVisual *visual, gpointer data, gint w, gint h)
GdkImage *image;
GdkImagePrivateFB *private;
- private = g_new(GdkImagePrivateFB, 1);
- image = (GdkImage *) private;
- private->base.ref_count = 1;
- private->base.klass = &image_class_normal;
+ image = (GdkImage *)private = (GdkImagePrivateFB *)g_type_create_instance(gdk_image_get_type());
image->type = GDK_IMAGE_NORMAL;
image->visual = visual;
image->width = w;
return image;
}
-void
-gdk_image_init (void)
-{
-}
-
GdkImage*
gdk_image_new (GdkImageType type,
GdkVisual *visual,
GdkImage *image;
GdkImagePrivateFB *private;
- private = g_new (GdkImagePrivateFB, 1);
- image = (GdkImage*) private;
+ image = (GdkImage *)private = (GdkImagePrivateFB *)g_type_create_instance(gdk_image_get_type());
- private->base.ref_count = 1;
-
image->type = 0;
image->visual = visual;
image->width = width;
image->height = height;
image->depth = visual->depth;
- private->base.klass = &image_class_normal;
-
- if (image)
- {
- image->byte_order = 0;
- image->mem = g_malloc(width * height * (image->depth >> 3));
- image->bpp = image->depth/8;
- image->bpl = (width * image->depth + 7)/8;
- }
+ image->byte_order = 0;
+ image->mem = g_malloc(width * height * (image->depth >> 3));
+ image->bpp = image->depth/8;
+ image->bpl = (width * image->depth + 7)/8;
return image;
}
{
GdkImage *image;
GdkImagePrivateFB *private;
- gint bits_per_pixel = GDK_DRAWABLE_P(gdk_parent_root)->depth;
+ gint bits_per_pixel = GDK_DRAWABLE_IMPL_FBDATA(gdk_parent_root)->depth;
GdkPixmapFBData fbd;
- GdkDrawablePrivate tmp_foo;
g_return_val_if_fail (window != NULL, NULL);
- if (GDK_DRAWABLE_DESTROYED (window))
- return NULL;
-
- private = g_new (GdkImagePrivateFB, 1);
- image = (GdkImage*) private;
-
- private->base.ref_count = 1;
- private->base.klass = &image_class_normal;
+ image = (GdkImage *)private = (GdkImagePrivateFB *)g_type_create_instance(gdk_image_get_type());
image->type = GDK_IMAGE_NORMAL;
image->visual = gdk_window_get_visual (window);
image->mem = g_malloc(image->bpl * image->height);
/* Fake its existence as a pixmap */
- memset(&tmp_foo, 0, sizeof(tmp_foo));
memset(&fbd, 0, sizeof(fbd));
- tmp_foo.klass = &_gdk_fb_drawable_class;
- tmp_foo.klass_data = &fbd;
fbd.drawable_data.mem = image->mem;
fbd.drawable_data.rowstride = image->bpl;
- tmp_foo.width = fbd.drawable_data.lim_x = image->width;
- tmp_foo.height = fbd.drawable_data.lim_y = image->height;
- tmp_foo.depth = image->depth;
- tmp_foo.window_type = GDK_DRAWABLE_PIXMAP;
+ fbd.drawable_data.width = fbd.drawable_data.lim_x = image->width;
+ fbd.drawable_data.height = fbd.drawable_data.lim_y = image->height;
+ fbd.drawable_data.depth = image->depth;
+ fbd.drawable_data.window_type = GDK_DRAWABLE_PIXMAP;
- gdk_fb_draw_drawable((GdkPixmap *)&tmp_foo, NULL, window, x, y, 0, 0, width, height);
+ gdk_fb_draw_drawable_2((GdkPixmap *)&fbd, NULL, window, x, y, 0, 0, width, height, TRUE, TRUE);
return image;
}
}
}
-static void
-gdk_fb_image_destroy (GdkImage *image)
-{
- GdkImagePrivateFB *private;
-
- g_return_if_fail (image != NULL);
-
- private = (GdkImagePrivateFB*) image;
-
- g_free(image->mem); image->mem = NULL;
-
- g_free (image);
-}
-
-static void
-gdk_image_put_normal (GdkImage *image,
- GdkDrawable *drawable,
- GdkGC *gc,
- gint xsrc,
- gint ysrc,
- gint xdest,
- gint ydest,
- gint width,
- gint height)
-{
- GdkImagePrivateFB *image_private;
- GdkPixmapFBData fbd;
- GdkDrawablePrivate tmp_foo;
-
- g_return_if_fail (drawable != NULL);
- g_return_if_fail (image != NULL);
- g_return_if_fail (gc != NULL);
-
- if (GDK_DRAWABLE_DESTROYED (drawable))
- return;
-
- image_private = (GdkImagePrivateFB*) image;
-
- g_return_if_fail (image->type == GDK_IMAGE_NORMAL);
-
- /* Fake its existence as a pixmap */
- memset(&tmp_foo, 0, sizeof(tmp_foo));
- memset(&fbd, 0, sizeof(fbd));
- tmp_foo.klass = &_gdk_fb_drawable_class;
- tmp_foo.klass_data = &fbd;
- fbd.drawable_data.mem = image->mem;
- fbd.drawable_data.rowstride = image->bpl;
- tmp_foo.width = fbd.drawable_data.lim_x = image->width;
- tmp_foo.height = fbd.drawable_data.lim_y = image->height;
- tmp_foo.depth = image->depth;
- tmp_foo.window_type = GDK_DRAWABLE_PIXMAP;
-
- gdk_fb_draw_drawable(drawable, gc, (GdkPixmap *)&tmp_foo, xsrc, ysrc, xdest, ydest, width, height);
-}
-
void
gdk_image_exit(void)
{
gboolean caps_lock : 1;
} Keyboard;
-static void gdk_input_ps2_get_pointer (GdkWindow *window,
- guint32 deviceid,
- gdouble *x,
- gdouble *y,
- gdouble *pressure,
- gdouble *xtilt,
- gdouble *ytilt,
- GdkModifierType *mask);
static Keyboard * tty_keyboard_open(void);
static guint keyboard_get_state(Keyboard *k);
-static PS2Mouse *ps2mouse = NULL;
+PS2Mouse *gdk_fb_ps2mouse = NULL;
static Keyboard *keyboard = NULL;
FILE *debug_out;
event->button.x = x;
event->button.y = y;
event->button.button = button;
- event->button.pressure = 0.5;
- event->button.xtilt = event->button.ytilt = 0;
event->button.state = (mouse->button1_pressed?GDK_BUTTON1_MASK:0)
| (mouse->button2_pressed?GDK_BUTTON2_MASK:0)
| (mouse->button3_pressed?GDK_BUTTON3_MASK:0)
| (1 << (button + 8)) /* badhack */
| keyboard_get_state(keyboard);
- event->button.source = GDK_SOURCE_MOUSE;
- event->button.deviceid = 0;
+ event->button.device = gdk_core_pointer;
event->button.x_root = mouse->x;
event->button.y_root = mouse->y;
tmp_gc = gdk_gc_new(window);
GDK_GC_FBDATA(tmp_gc)->values.foreground.pixel = 0;
- gdk_fb_draw_rectangle(window, tmp_gc, TRUE, 0, 0,
- GDK_DRAWABLE_P(window)->width, GDK_DRAWABLE_P(window)->height);
+ gdk_fb_draw_rectangle(GDK_DRAWABLE_IMPL(window), tmp_gc, TRUE, 0, 0,
+ GDK_DRAWABLE_IMPL_FBDATA(window)->width, GDK_DRAWABLE_IMPL_FBDATA(window)->height);
gdk_gc_unref(tmp_gc);
}
#endif
GdkFBDrawingContext *gdk_fb_cursor_dc = NULL;
static GdkFBDrawingContext cursor_dc_dat;
static GdkGC *cursor_gc;
+static gint cursor_visibility_count = 1;
static GdkFBDrawingContext *
gdk_fb_cursor_dc_reset(void)
gdk_fb_drawing_context_finalize(gdk_fb_cursor_dc);
gdk_fb_cursor_dc = &cursor_dc_dat;
- gdk_fb_drawing_context_init(gdk_fb_cursor_dc, gdk_parent_root, cursor_gc, TRUE, FALSE);
+ gdk_fb_drawing_context_init(gdk_fb_cursor_dc, GDK_DRAWABLE_IMPL(gdk_parent_root), cursor_gc, TRUE, FALSE);
return gdk_fb_cursor_dc;
}
{
GdkFBDrawingContext *mydc = gdk_fb_cursor_dc;
+ cursor_visibility_count--;
+ g_assert(cursor_visibility_count <= 0);
+ if(cursor_visibility_count < 0)
+ return;
+
if(!mydc)
mydc = gdk_fb_cursor_dc_reset();
{
gdk_gc_set_clip_mask(cursor_gc, NULL);
/* Restore old picture */
- gdk_fb_draw_drawable_3(gdk_parent_root, cursor_gc, last_contents,
+ gdk_fb_draw_drawable_3(GDK_DRAWABLE_IMPL(gdk_parent_root), cursor_gc, GDK_DRAWABLE_IMPL(last_contents),
mydc,
0, 0,
last_location.x,
void
gdk_fb_cursor_invalidate(void)
{
- gdk_pixmap_unref(last_contents);
- last_contents = NULL;
+ if(last_contents)
+ {
+ gdk_pixmap_unref(last_contents);
+ last_contents = NULL;
+ }
}
void
{
GdkFBDrawingContext *mydc = gdk_fb_cursor_dc;
+ cursor_visibility_count++;
+ g_assert(cursor_visibility_count <= 1);
+ if(cursor_visibility_count < 1)
+ return;
+
if(!mydc)
mydc = gdk_fb_cursor_dc_reset();
if(last_cursor)
{
if(!last_contents
- || GDK_DRAWABLE_P(GDK_CURSOR_FB(last_cursor)->cursor)->width > GDK_DRAWABLE_P(last_contents)->width
- || GDK_DRAWABLE_P(GDK_CURSOR_FB(last_cursor)->cursor)->height > GDK_DRAWABLE_P(last_contents)->height)
+ || GDK_DRAWABLE_IMPL_FBDATA(GDK_CURSOR_FB(last_cursor)->cursor)->width > GDK_DRAWABLE_IMPL_FBDATA(last_contents)->width
+ || GDK_DRAWABLE_IMPL_FBDATA(GDK_CURSOR_FB(last_cursor)->cursor)->height > GDK_DRAWABLE_IMPL_FBDATA(last_contents)->height)
{
if(last_contents)
gdk_pixmap_unref(last_contents);
last_contents = gdk_pixmap_new(gdk_parent_root,
- GDK_DRAWABLE_P(GDK_CURSOR_FB(last_cursor)->cursor)->width,
- GDK_DRAWABLE_P(GDK_CURSOR_FB(last_cursor)->cursor)->height,
- GDK_DRAWABLE_P(gdk_parent_root)->depth);
+ GDK_DRAWABLE_IMPL_FBDATA(GDK_CURSOR_FB(last_cursor)->cursor)->width,
+ GDK_DRAWABLE_IMPL_FBDATA(GDK_CURSOR_FB(last_cursor)->cursor)->height,
+ GDK_DRAWABLE_IMPL_FBDATA(gdk_parent_root)->depth);
}
gdk_gc_set_clip_mask(cursor_gc, NULL);
- gdk_fb_draw_drawable_2(last_contents, cursor_gc, gdk_parent_root, last_location.x,
+ gdk_fb_draw_drawable_2(GDK_DRAWABLE_IMPL(last_contents), cursor_gc, GDK_DRAWABLE_IMPL(gdk_parent_root), last_location.x,
last_location.y, 0, 0,
- GDK_DRAWABLE_P(GDK_CURSOR_FB(last_cursor)->cursor)->width,
- GDK_DRAWABLE_P(GDK_CURSOR_FB(last_cursor)->cursor)->height, TRUE, FALSE);
- last_contents_size.x = GDK_DRAWABLE_P(GDK_CURSOR_FB(last_cursor)->cursor)->width;
- last_contents_size.y = GDK_DRAWABLE_P(GDK_CURSOR_FB(last_cursor)->cursor)->height;
+ GDK_DRAWABLE_IMPL_FBDATA(GDK_CURSOR_FB(last_cursor)->cursor)->width,
+ GDK_DRAWABLE_IMPL_FBDATA(GDK_CURSOR_FB(last_cursor)->cursor)->height, TRUE, FALSE);
+ last_contents_size.x = GDK_DRAWABLE_IMPL_FBDATA(GDK_CURSOR_FB(last_cursor)->cursor)->width;
+ last_contents_size.y = GDK_DRAWABLE_IMPL_FBDATA(GDK_CURSOR_FB(last_cursor)->cursor)->height;
gdk_gc_set_clip_mask(cursor_gc, GDK_CURSOR_FB(last_cursor)->mask);
- gdk_gc_set_clip_origin(cursor_gc, last_location.x, last_location.y);
+ gdk_gc_set_clip_origin(cursor_gc, last_location.x + GDK_CURSOR_FB(last_cursor)->mask_off_x,
+ last_location.y + GDK_CURSOR_FB(last_cursor)->mask_off_y);
gdk_fb_cursor_dc_reset();
- gdk_fb_draw_drawable_3(gdk_parent_root, cursor_gc, GDK_CURSOR_FB(last_cursor)->cursor, mydc,
- 0, 0, last_location.x, last_location.y,
- GDK_DRAWABLE_P(GDK_CURSOR_FB(last_cursor)->cursor)->width,
- GDK_DRAWABLE_P(GDK_CURSOR_FB(last_cursor)->cursor)->height);
+ gdk_fb_draw_drawable_3(GDK_DRAWABLE_IMPL(gdk_parent_root), cursor_gc, GDK_DRAWABLE_IMPL(GDK_CURSOR_FB(last_cursor)->cursor),
+ mydc, 0, 0, last_location.x, last_location.y,
+ GDK_DRAWABLE_IMPL_FBDATA(GDK_CURSOR_FB(last_cursor)->cursor)->width,
+ GDK_DRAWABLE_IMPL_FBDATA(GDK_CURSOR_FB(last_cursor)->cursor)->height);
}
else
gdk_fb_cursor_invalidate();
}
+gboolean
+gdk_fb_cursor_region_need_hide(GdkRegion *region)
+{
+ GdkRectangle testme;
+
+ if(!last_cursor)
+ return FALSE;
+
+ testme.x = last_location.x;
+ testme.y = last_location.y;
+ testme.width = GDK_DRAWABLE_IMPL_FBDATA(GDK_CURSOR_FB(last_cursor)->cursor)->width;
+ testme.height = GDK_DRAWABLE_IMPL_FBDATA(GDK_CURSOR_FB(last_cursor)->cursor)->height;
+
+ return (gdk_region_rect_in(region, &testme)!=GDK_OVERLAP_RECTANGLE_OUT);
+}
+
+gboolean
+gdk_fb_cursor_need_hide(GdkRectangle *rect)
+{
+ GdkRectangle testme;
+
+ if(!last_cursor)
+ return FALSE;
+
+ testme.x = last_location.x;
+ testme.y = last_location.y;
+ testme.width = GDK_DRAWABLE_IMPL_FBDATA(GDK_CURSOR_FB(last_cursor)->cursor)->width;
+ testme.height = GDK_DRAWABLE_IMPL_FBDATA(GDK_CURSOR_FB(last_cursor)->cursor)->height;
+
+ return gdk_rectangle_intersect(rect, &testme, &testme);
+}
+
void
gdk_fb_get_cursor_rect(GdkRectangle *rect)
{
{
rect->x = last_location.x;
rect->y = last_location.y;
- rect->width = GDK_DRAWABLE_P(GDK_CURSOR_FB(last_cursor)->cursor)->width;
- rect->height = GDK_DRAWABLE_P(GDK_CURSOR_FB(last_cursor)->cursor)->height;
+ rect->width = GDK_DRAWABLE_IMPL_FBDATA(GDK_CURSOR_FB(last_cursor)->cursor)->width;
+ rect->height = GDK_DRAWABLE_IMPL_FBDATA(GDK_CURSOR_FB(last_cursor)->cursor)->height;
}
else
{
the_cursor = _gdk_fb_pointer_grab_cursor;
else
{
- while(!GDK_WINDOW_FBDATA(in_window)->cursor && GDK_WINDOW_P(in_window)->parent)
- in_window = GDK_WINDOW_P(in_window)->parent;
- the_cursor = GDK_WINDOW_FBDATA(in_window)->cursor;
+ while(!GDK_WINDOW_IMPL_FBDATA(in_window)->cursor && GDK_WINDOW_P(in_window)->parent)
+ in_window = (GdkWindow *)GDK_WINDOW_P(in_window)->parent;
+ the_cursor = GDK_WINDOW_IMPL_FBDATA(in_window)->cursor;
}
last_location.x = mouse->x - GDK_CURSOR_FB(the_cursor)->hot_x;
gdk_fb_cursor_unhide();
}
+void
+gdk_fb_cursor_reset(void)
+{
+ GdkWindow *win = gdk_window_get_pointer(NULL, NULL, NULL, NULL);
+
+ move_pointer(gdk_fb_ps2mouse, win);
+}
+
+void gdk_fb_window_visibility_crossing(GdkWindow *window, gboolean is_show)
+{
+ gint winx, winy;
+ GdkModifierType my_mask;
+
+ gdk_input_ps2_get_mouseinfo(&winx, &winy, &my_mask);
+
+ if(winx >= GDK_DRAWABLE_IMPL_FBDATA(window)->llim_x
+ && winx < GDK_DRAWABLE_IMPL_FBDATA(window)->lim_x
+ && winy >= GDK_DRAWABLE_IMPL_FBDATA(window)->llim_y
+ && winy < GDK_DRAWABLE_IMPL_FBDATA(window)->lim_y)
+ {
+ GdkWindow *oldwin, *newwin, *curwin;
+ GdkEvent *event;
+
+ curwin = gdk_window_get_pointer(NULL, NULL, NULL, NULL);
+
+ if(is_show)
+ {
+ /* Window is about to be shown */
+ oldwin = curwin;
+ newwin = window;
+ }
+ else
+ {
+ /* Window is about to be hidden */
+ oldwin = window;
+ newwin = curwin;
+ }
+
+ event = gdk_event_make(oldwin, GDK_LEAVE_NOTIFY, TRUE);
+ if(event)
+ {
+ guint x_int, y_int;
+ event->crossing.subwindow = gdk_window_ref(newwin);
+ gdk_window_get_root_origin(oldwin, &x_int, &y_int);
+ event->crossing.x = winx - x_int;
+ event->crossing.y = winy - y_int;
+ event->crossing.x_root = winx;
+ event->crossing.y_root = winy;
+ event->crossing.mode = GDK_CROSSING_NORMAL;
+ event->crossing.detail = GDK_NOTIFY_UNKNOWN;
+ event->crossing.focus = FALSE;
+ event->crossing.state = my_mask;
+ }
+
+ event = gdk_event_make(newwin, GDK_ENTER_NOTIFY, TRUE);
+ if(event)
+ {
+ guint x_int, y_int;
+ event->crossing.subwindow = gdk_window_ref(oldwin);
+ gdk_window_get_root_origin(newwin, &x_int, &y_int);
+ event->crossing.x = winx - x_int;
+ event->crossing.y = winy - y_int;
+ event->crossing.x_root = winx;
+ event->crossing.y_root = winy;
+ event->crossing.mode = GDK_CROSSING_NORMAL;
+ event->crossing.detail = GDK_NOTIFY_UNKNOWN;
+ event->crossing.focus = FALSE;
+ event->crossing.state = my_mask;
+ }
+
+ if(gdk_fb_ps2mouse->prev_window)
+ gdk_window_unref(gdk_fb_ps2mouse->prev_window);
+ gdk_fb_ps2mouse->prev_window = gdk_window_ref(newwin);
+ }
+}
+
static gboolean
handle_input(GIOChannel *gioc, GIOCondition cond, gpointer data)
{
gboolean new_button1, new_button2, new_button3;
time_t the_time = g_latest_time.tv_sec;
GdkWindow *mousewin;
+ gboolean got_motion = FALSE;
- for(left = sizeof(buf); left > 0; )
+ while(1) /* Go through as many mouse events as we can */
{
- n = read(mouse->fd, buf+sizeof(buf)-left, left);
- g_assert(n > 0);
- left -= n;
- }
+ for(left = sizeof(buf); left > 0; )
+ {
+ n = read(mouse->fd, buf+sizeof(buf)-left, left);
- new_button1 = (buf[0] & 1) && 1;
- new_button3 = (buf[0] & 2) && 1;
- new_button2 = (buf[0] & 4) && 1;
+ if(n <= 0)
+ {
+ if(left != sizeof(buf))
+ continue; /* XXX FIXME - this will be slow compared to turning on blocking mode, etc. */
- if(new_button1 != mouse->button1_pressed)
- {
- mouse->button1_pressed = new_button1;
- send_button_event(mouse, 1, new_button1, the_time);
- }
+ goto done_reading_mouse_events;
+ }
- if(new_button2 != mouse->button2_pressed)
- {
- mouse->button2_pressed = new_button2;
- send_button_event(mouse, 2, new_button2, the_time);
- }
+ left -= n;
+ }
- if(new_button3 != mouse->button3_pressed)
- {
- mouse->button3_pressed = new_button3;
- send_button_event(mouse, 3, new_button3, the_time);
- }
+ new_button1 = (buf[0] & 1) && 1;
+ new_button3 = (buf[0] & 2) && 1;
+ new_button2 = (buf[0] & 4) && 1;
- if(buf[1] != 0)
- dx = ((buf[0] & 0x10) ? ((gint)buf[1])-256 : buf[1]);
- else
- dx = 0;
- if(buf[2] != 0)
- dy = -((buf[0] & 0x20) ? ((gint)buf[2])-256 : buf[2]);
- else
- dy = 0;
+ if(new_button1 != mouse->button1_pressed)
+ {
+ mouse->button1_pressed = new_button1;
+ send_button_event(mouse, 1, new_button1, the_time);
+ }
+
+ if(new_button2 != mouse->button2_pressed)
+ {
+ mouse->button2_pressed = new_button2;
+ send_button_event(mouse, 2, new_button2, the_time);
+ }
+
+ if(new_button3 != mouse->button3_pressed)
+ {
+ mouse->button3_pressed = new_button3;
+ send_button_event(mouse, 3, new_button3, the_time);
+ }
+
+ if(buf[1] != 0)
+ dx = ((buf[0] & 0x10) ? ((gint)buf[1])-256 : buf[1]);
+ else
+ dx = 0;
+ if(buf[2] != 0)
+ dy = -((buf[0] & 0x20) ? ((gint)buf[2])-256 : buf[2]);
+ else
+ dy = 0;
+
+ mouse->x += dx;
+ mouse->y += dy;
+ if(dx || dy)
+ got_motion = TRUE;
+ }
+ done_reading_mouse_events:
- mouse->x += dx;
- mouse->y += dy;
if(_gdk_fb_pointer_grab_confine)
mousewin = _gdk_fb_pointer_grab_confine;
else
if(mouse->x < 0)
mouse->x = 0;
- else if(mouse->x > (GDK_DRAWABLE_FBDATA(mousewin)->lim_x - 1))
- mouse->x = GDK_DRAWABLE_FBDATA(mousewin)->lim_x - 1;
+ else if(mouse->x > (GDK_DRAWABLE_IMPL_FBDATA(mousewin)->lim_x - 1))
+ mouse->x = GDK_DRAWABLE_IMPL_FBDATA(mousewin)->lim_x - 1;
if(mouse->y < 0)
mouse->y = 0;
- else if(mouse->y > (GDK_DRAWABLE_FBDATA(mousewin)->lim_y - 1))
- mouse->y = GDK_DRAWABLE_FBDATA(mousewin)->lim_y - 1;
+ else if(mouse->y > (GDK_DRAWABLE_IMPL_FBDATA(mousewin)->lim_y - 1))
+ mouse->y = GDK_DRAWABLE_IMPL_FBDATA(mousewin)->lim_y - 1;
- if(dx || dy) {
+ if(got_motion) {
GdkEvent *event;
gint x, y;
GdkWindow *win;
{
event->motion.x = x;
event->motion.y = y;
- event->motion.pressure = 0.5;
- event->motion.xtilt = event->motion.ytilt = 0;
event->motion.state = state;
event->motion.is_hint = FALSE;
- event->motion.source = GDK_SOURCE_MOUSE;
- event->motion.deviceid = 0;
+ event->motion.device = gdk_core_pointer;
event->motion.x_root = mouse->x;
event->motion.y_root = mouse->y;
}
write(retval->fd, buf, i);
read(retval->fd, buf, 3); /* Get rid of misc garbage whatever stuff from mouse */
+ fcntl(retval->fd, F_SETFL, O_RDWR|O_NONBLOCK);
+
gioc = g_io_channel_unix_new(retval->fd);
retval->fd_tag = g_io_add_watch(gioc, G_IO_IN|G_IO_ERR|G_IO_HUP|G_IO_NVAL, handle_input, retval);
void
gdk_input_init (void)
{
- gdk_input_vtable.set_mode = NULL;
- gdk_input_vtable.set_axes = NULL;
- gdk_input_vtable.set_key = NULL;
- gdk_input_vtable.motion_events = NULL;
- gdk_input_vtable.get_pointer = gdk_input_ps2_get_pointer;
- gdk_input_vtable.grab_pointer = NULL;
- gdk_input_vtable.ungrab_pointer = NULL;
- gdk_input_vtable.configure_event = NULL;
- gdk_input_vtable.enter_event = NULL;
- gdk_input_vtable.other_event = NULL;
- gdk_input_vtable.window_none_event = NULL;
- gdk_input_vtable.enable_window = NULL;
- gdk_input_vtable.disable_window = NULL;
-
- gdk_input_devices = g_list_append (NULL, (GdkDeviceInfo *) &gdk_input_core_info);
+ gdk_input_devices = g_list_append (NULL, gdk_core_pointer);
gdk_input_ignore_core = FALSE;
- ps2mouse = mouse_open();
+ gdk_fb_ps2mouse = mouse_open();
}
void
gdk_input_ps2_get_mouseinfo(gint *x, gint *y, GdkModifierType *mask)
{
- *x = ps2mouse->x;
- *y = ps2mouse->y;
+ *x = gdk_fb_ps2mouse->x;
+ *y = gdk_fb_ps2mouse->y;
*mask =
- (ps2mouse->button1_pressed?GDK_BUTTON1_MASK:0)
- | (ps2mouse->button2_pressed?GDK_BUTTON2_MASK:0)
- | (ps2mouse->button3_pressed?GDK_BUTTON3_MASK:0)
+ (gdk_fb_ps2mouse->button1_pressed?GDK_BUTTON1_MASK:0)
+ | (gdk_fb_ps2mouse->button2_pressed?GDK_BUTTON2_MASK:0)
+ | (gdk_fb_ps2mouse->button3_pressed?GDK_BUTTON3_MASK:0)
| keyboard_get_state(keyboard);
}
-static void
-gdk_input_ps2_get_pointer (GdkWindow *window,
- guint32 deviceid,
- gdouble *x,
- gdouble *y,
- gdouble *pressure,
- gdouble *xtilt,
- gdouble *ytilt,
- GdkModifierType *mask)
-{
- gint x_int, y_int;
-
- gdk_window_get_root_origin(window, &x_int, &y_int);
-
- if (x) *x = ps2mouse->x - x_int;
- if (y) *y = ps2mouse->y - y_int;
- if (pressure) *pressure = 0.5;
- if (xtilt) *xtilt = 0;
- if (ytilt) *ytilt = 0;
-}
-
/* Returns the modifier mask for the keyboard */
static guint
keyboard_get_state(Keyboard *k)
return gdk_parent_root;
}
-static gboolean
-handle_keyboard_input(GIOChannel *gioc, GIOCondition cond, gpointer data)
-{
- guchar buf[128];
- int i, n;
- Keyboard *k = data;
- time_t now;
-
- n = read(k->fd, buf, sizeof(buf));
- if(n <= 0)
- g_error("Nothing from keyboard!");
-
- /* Now turn this into a keyboard event */
- now = g_latest_time.tv_sec;
-
- for(i = 0; i < n; i++)
- {
- guchar base_char;
- static const guint trans_table[256][3] = {
- /* 0x00 */
- {0, 0, 0},
- {GDK_Escape, 0, 0},
- {'1', '!', 0},
- {'2', '@', 0},
- {'3', '#', 0},
- {'4', '$', 0},
- {'5', '%', 0},
- {'6', '^', 0},
- {'7', '&', 0},
- {'8', '*', 0},
- {'9', '(', 0},
- {'0', ')', 0},
- {'-', '_', 0},
- {'=', '+', 0},
- {GDK_BackSpace, 0, 0},
- {GDK_Tab, 0, 0},
-
- /* 0x10 */
- {'q', 'Q', 0},
- {'w', 'W', 0},
- {'e', 'E', 0},
- {'r', 'R', 0},
- {'t', 'T', 0},
- {'y', 'Y', 0},
- {'u', 'U', 0},
- {'i', 'I', 0},
- {'o', 'O', 0},
- {'p', 'P', 0},
- {'[', '{', 0},
- {']', '}', 0},
- {GDK_Return, 0, 0},
- {GDK_Control_L, 0, 0}, /* mod */
- {'a', 'A', 0},
- {'s', 'S', 0},
+static const guint trans_table[256][3] = {
+ /* 0x00 */
+ {0, 0, 0},
+ {GDK_Escape, 0, 0},
+ {'1', '!', 0},
+ {'2', '@', 0},
+ {'3', '#', 0},
+ {'4', '$', 0},
+ {'5', '%', 0},
+ {'6', '^', 0},
+ {'7', '&', 0},
+ {'8', '*', 0},
+ {'9', '(', 0},
+ {'0', ')', 0},
+ {'-', '_', 0},
+ {'=', '+', 0},
+ {GDK_BackSpace, 0, 0},
+ {GDK_Tab, 0, 0},
+
+ /* 0x10 */
+ {'q', 'Q', 0},
+ {'w', 'W', 0},
+ {'e', 'E', 0},
+ {'r', 'R', 0},
+ {'t', 'T', 0},
+ {'y', 'Y', 0},
+ {'u', 'U', 0},
+ {'i', 'I', 0},
+ {'o', 'O', 0},
+ {'p', 'P', 0},
+ {'[', '{', 0},
+ {']', '}', 0},
+ {GDK_Return, 0, 0},
+ {GDK_Control_L, 0, 0}, /* mod */
+ {'a', 'A', 0},
+ {'s', 'S', 0},
/* 0x20 */
- {'d', 'D', 0},
- {'f', 'F', 0},
- {'g', 'G', 0},
- {'h', 'H', 0},
- {'j', 'J', 0},
- {'k', 'K', 0},
- {'l', 'L', 0},
- {';', ':', 0},
- {'\'', '"', 0},
- {'`', '~', 0},
- {GDK_Shift_L, 0, 0}, /* mod */
- {'\\', 0, 0},
- {'z', 0, 0},
- {'x', 0, 0},
- {'c', 0, 0},
-
- {'v', 'V', 0},
+ {'d', 'D', 0},
+ {'f', 'F', 0},
+ {'g', 'G', 0},
+ {'h', 'H', 0},
+ {'j', 'J', 0},
+ {'k', 'K', 0},
+ {'l', 'L', 0},
+ {';', ':', 0},
+ {'\'', '"', 0},
+ {'`', '~', 0},
+ {GDK_Shift_L, 0, 0}, /* mod */
+ {'\\', 0, 0},
+ {'z', 0, 0},
+ {'x', 0, 0},
+ {'c', 0, 0},
+
+ {'v', 'V', 0},
/* 0x30 */
- {'b', 'B', 0},
- {'n', 'N', 0},
- {'m', 'M', 0},
- {',', 0, 0},
- {'.', 0, 0},
- {'/', 0, 0},
- {GDK_Shift_R, 0, 0}, /* mod */
- {GDK_KP_Multiply, 0, 0},
- {0, 0, 0},
- {GDK_space, 0, 0},
- {0, 0, 0},
- {GDK_F1, 0, 0},
- {GDK_F2, 0, 0},
- {GDK_F3, 0, 0},
- {GDK_F4, 0, 0},
- {GDK_F5, 0, 0},
+ {'b', 'B', 0},
+ {'n', 'N', 0},
+ {'m', 'M', 0},
+ {',', 0, 0},
+ {'.', 0, 0},
+ {'/', 0, 0},
+ {GDK_Shift_R, 0, 0}, /* mod */
+ {GDK_KP_Multiply, 0, 0},
+ {0, 0, 0},
+ {GDK_space, 0, 0},
+ {0, 0, 0},
+ {GDK_F1, 0, 0},
+ {GDK_F2, 0, 0},
+ {GDK_F3, 0, 0},
+ {GDK_F4, 0, 0},
+ {GDK_F5, 0, 0},
/* 0x40 */
- {GDK_F6, 0, 0},
- {GDK_F7, 0, 0},
- {GDK_F8, 0, 0},
- {GDK_F9, 0, 0},
- {GDK_F10, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
+ {GDK_F6, 0, 0},
+ {GDK_F7, 0, 0},
+ {GDK_F8, 0, 0},
+ {GDK_F9, 0, 0},
+ {GDK_F10, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
/* 0x50 */
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {GDK_F11, 0, 0},
- {GDK_F12, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {GDK_F11, 0, 0},
+ {GDK_F12, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
/* 0x60 */
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
/* 0x70 */
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
/* 0x80 */
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
/* 0x90 */
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
/* 0xA0 */
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
/* 0xB0 */
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
/* 0xC0 */
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {GDK_Up, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {GDK_Left, 0, 0},
- {GDK_Right, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {GDK_Up, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {GDK_Left, 0, 0},
+ {GDK_Right, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
/* 0xD0 */
- {GDK_Down, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
+ {GDK_Down, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
/* 0xE0 */
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
/* 0xF0 */
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- {0, 0, 0},
- };
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+ {0, 0, 0},
+};
+static gboolean
+handle_keyboard_input(GIOChannel *gioc, GIOCondition cond, gpointer data)
+{
+ guchar buf[128];
+ int i, n;
+ Keyboard *k = data;
+ time_t now;
+
+ n = read(k->fd, buf, sizeof(buf));
+ if(n <= 0)
+ g_error("Nothing from keyboard!");
+
+ /* Now turn this into a keyboard event */
+ now = g_latest_time.tv_sec;
+
+ for(i = 0; i < n; i++)
+ {
+ guchar base_char;
GdkEvent *event;
GdkWindow *win;
char dummy[2];
mod = 1;
do {
keyval = trans_table[base_char][mod--];
- } while(!keyval && (mod > 0));
+ } while(!keyval && (mod >= 0));
if(k->caps_lock && (keyval >= 'a')
&& (keyval <= 'z'))
keyval = toupper(keyval);
+ /* handle some magic keys */
+ if(state & (GDK_CONTROL_MASK|GDK_MOD1_MASK))
+ {
+ if(!k->states[base_char])
+ {
+ if(keyval == GDK_BackSpace)
+ exit(1);
+
+ if(keyval == GDK_Return)
+ gdk_fb_redraw_all();
+
+ }
+
+ keyval = 0;
+ }
+
+ if(!keyval)
+ continue;
+
win = gdk_window_find_focus();
event = gdk_event_make(win, k->states[base_char]?GDK_KEY_PRESS:GDK_KEY_RELEASE, TRUE);
if(event)
#include <stdlib.h>
#include "config.h"
-#include "gdkfb.h"
+#include "gdkprivate-fb.h"
#include "gdkinput.h"
#include "gdkprivate.h"
#include "gdkinputprivate.h"
-static const GdkAxisUse gdk_input_core_axes[] = { GDK_AXIS_X, GDK_AXIS_Y };
+static const GdkDeviceAxis gdk_input_core_axes[] = {
+ { GDK_AXIS_X, 0, 0 },
+ { GDK_AXIS_Y, 0, 0 }
+};
-const GdkDeviceInfo gdk_input_core_info =
+static GdkDevice gdk_input_core_info =
{
- GDK_CORE_POINTER,
"Core Pointer",
GDK_SOURCE_MOUSE,
GDK_MODE_SCREEN,
TRUE,
2,
- gdk_input_core_axes
+ (GdkDeviceAxis *)gdk_input_core_axes,
+ 0,
+ NULL
};
+GdkDevice *gdk_core_pointer = (GdkDevice *)&gdk_input_core_info;
+
/* Global variables */
-GdkInputVTable gdk_input_vtable;
-/* information about network port and host for gxid daemon */
gchar *gdk_input_gxid_host;
gint gdk_input_gxid_port;
gint gdk_input_ignore_core;
-
-GList *gdk_input_devices;
GList *gdk_input_windows;
+GList *gdk_input_devices;
GList *
-gdk_input_list_devices (void)
+gdk_devices_list (void)
{
return gdk_input_devices;
}
void
-gdk_input_set_source (guint32 deviceid, GdkInputSource source)
+gdk_device_set_source (GdkDevice *device, GdkInputSource source)
{
- GdkDevicePrivate *gdkdev = gdk_input_find_device(deviceid);
- g_return_if_fail (gdkdev != NULL);
-
- gdkdev->info.source = source;
+ device->source = source;
}
-gint
-gdk_input_set_mode (guint32 deviceid, GdkInputMode mode)
+
+void
+gdk_device_set_key (GdkDevice *device,
+ guint index,
+ guint keyval,
+ GdkModifierType modifiers)
{
- if (deviceid == GDK_CORE_POINTER)
- return FALSE;
+ g_return_if_fail (device != NULL);
+ g_return_if_fail (index < device->num_keys);
- if (gdk_input_vtable.set_mode)
- return gdk_input_vtable.set_mode(deviceid,mode);
- else
- return FALSE;
+ device->keys[index].keyval = keyval;
+ device->keys[index].modifiers = modifiers;
}
void
-gdk_input_set_axes (guint32 deviceid, GdkAxisUse *axes)
+gdk_device_set_axis_use (GdkDevice *device,
+ guint index,
+ GdkAxisUse use)
+{
+ g_return_if_fail (device != NULL);
+ g_return_if_fail (index < device->num_axes);
+
+ device->axes[index].use = use;
+
+ switch (use)
+ {
+ case GDK_AXIS_X:
+ case GDK_AXIS_Y:
+ device->axes[index].min = 0.;
+ device->axes[index].max = 0.;
+ break;
+ case GDK_AXIS_XTILT:
+ case GDK_AXIS_YTILT:
+ device->axes[index].min = -1.;
+ device->axes[index].max = 1;
+ break;
+ default:
+ device->axes[index].min = 0.;
+ device->axes[index].max = 1;
+ break;
+ }
+}
+
+void
+gdk_device_get_state (GdkDevice *device,
+ GdkWindow *window,
+ gdouble *axes,
+ GdkModifierType *mask)
{
- if (deviceid != GDK_CORE_POINTER && gdk_input_vtable.set_axes)
- gdk_input_vtable.set_axes (deviceid, axes);
+ gint x_int, y_int;
+
+ g_assert(device == gdk_core_pointer);
+
+ gdk_window_get_pointer (window, &x_int, &y_int, mask);
+
+ if (axes)
+ {
+ axes[0] = x_int;
+ axes[1] = y_int;
+ }
}
-void gdk_input_set_key (guint32 deviceid,
- guint index,
- guint keyval,
- GdkModifierType modifiers)
+void
+gdk_device_free_history (GdkTimeCoord **events,
+ gint n_events)
{
- if (deviceid != GDK_CORE_POINTER && gdk_input_vtable.set_key)
- gdk_input_vtable.set_key (deviceid, index, keyval, modifiers);
+ gint i;
+
+ for (i=0; i<n_events; i++)
+ g_free (events[i]);
+
+ g_free (events);
}
-GdkTimeCoord *
-gdk_input_motion_events (GdkWindow *window,
- guint32 deviceid,
- guint32 start,
- guint32 stop,
- gint *nevents_return)
+gboolean
+gdk_device_get_history (GdkDevice *device,
+ GdkWindow *window,
+ guint32 start,
+ guint32 stop,
+ GdkTimeCoord ***events,
+ gint *n_events)
{
- g_return_val_if_fail (window != NULL, NULL);
- g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
+ g_return_val_if_fail (window != NULL, FALSE);
+ g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
+ g_return_val_if_fail (events != NULL, FALSE);
+ g_return_val_if_fail (n_events != NULL, FALSE);
+
+ *n_events = 0;
+ *events = NULL;
+ return FALSE;
+}
- *nevents_return = 0;
- return NULL;
+gboolean
+gdk_device_set_mode (GdkDevice *device,
+ GdkInputMode mode)
+{
+ return FALSE;
}
gint
gdk_input_enable_window (GdkWindow *window, GdkDevicePrivate *gdkdev)
{
- if (gdk_input_vtable.enable_window)
- return gdk_input_vtable.enable_window (window, gdkdev);
- else
- return TRUE;
+ return TRUE;
}
gint
gdk_input_disable_window (GdkWindow *window, GdkDevicePrivate *gdkdev)
{
- if (gdk_input_vtable.disable_window)
- return gdk_input_vtable.disable_window(window,gdkdev);
- else
- return TRUE;
+ return TRUE;
}
g_return_if_fail (GDK_IS_WINDOW (window));
window_private = (GdkWindowPrivate*) window;
- if (GDK_DRAWABLE_DESTROYED (window))
- return;
if (mode == GDK_EXTENSION_EVENTS_NONE)
mask = 0;
{
GdkDevicePrivate *gdkdev = (GdkDevicePrivate *)(tmp_list->data);
- if (gdkdev->info.deviceid != GDK_CORE_POINTER)
+ if (gdkdev != (GdkDevicePrivate *)gdk_core_pointer)
{
if (mask != 0 && gdkdev->info.mode != GDK_MODE_DISABLED
&& (gdkdev->info.has_cursor || mode == GDK_EXTENSION_EVENTS_ALL))
for (tmp_list = gdk_input_devices; tmp_list; tmp_list = tmp_list->next)
{
gdkdev = (GdkDevicePrivate *)(tmp_list->data);
- if (gdkdev->info.deviceid != GDK_CORE_POINTER)
+ if (gdkdev != (GdkDevicePrivate *)gdk_core_pointer)
{
- gdk_input_set_mode(gdkdev->info.deviceid,GDK_MODE_DISABLED);
+ gdk_device_set_mode((GdkDevice *)gdkdev, GDK_MODE_DISABLED);
g_free(gdkdev->info.name);
g_free(gdkdev->info.axes);
g_list_free(gdk_input_windows);
}
-GdkDevicePrivate *
-gdk_input_find_device(guint32 id)
+/**
+ * gdk_device_get_axis:
+ * @axis: a #GdkDevice
+ * @axes: pointer to an array of axes
+ * @use: the use to look for
+ * @value: location to store the found value.
+ *
+ * Interprets an array of double as axis values for a given device,
+ * and locates the value in the array for a given axis use.
+ *
+ * Return value: %TRUE if the given axis use was found, otherwies %FALSE
+ **/
+gboolean
+gdk_device_get_axis (GdkDevice *device, gdouble *axes, GdkAxisUse use, gdouble *value)
{
- GList *tmp_list = gdk_input_devices;
- GdkDevicePrivate *gdkdev;
- while (tmp_list)
- {
- gdkdev = (GdkDevicePrivate *)(tmp_list->data);
- if (gdkdev->info.deviceid == id)
- return gdkdev;
- tmp_list = tmp_list->next;
- }
- return NULL;
-}
+ gint i;
+
+ g_return_val_if_fail (device != NULL, FALSE);
-void
-gdk_input_window_get_pointer (GdkWindow *window,
- guint32 deviceid,
- gdouble *x,
- gdouble *y,
- gdouble *pressure,
- gdouble *xtilt,
- gdouble *ytilt,
- GdkModifierType *mask)
-{
- if (gdk_input_vtable.get_pointer)
- gdk_input_vtable.get_pointer (window, deviceid, x, y, pressure,
- xtilt, ytilt, mask);
+ if (axes == NULL)
+ return FALSE;
+
+ for (i=0; i<device->num_axes; i++)
+ if (device->axes[i].use == use)
+ {
+ if (value)
+ *value = axes[i];
+ return TRUE;
+ }
+
+ return FALSE;
}
#define GDK_INPUT_NUM_EVENTC 6
struct _GdkDevicePrivate {
- GdkDeviceInfo info;
+ GdkDevice info;
};
struct _GdkInputWindow
/* Global data */
-extern const GdkDeviceInfo gdk_input_core_info;
+extern const GdkDevice gdk_input_core_info;
extern GList *gdk_input_devices;
extern GList *gdk_input_windows;
if(!owner_events)
_gdk_fb_pointer_grab_window = gdk_window_ref(window);
- if(cursor)
- gdk_fb_cursor_hide();
-
_gdk_fb_pointer_grab_confine = confine_to?gdk_window_ref(confine_to):NULL;
_gdk_fb_pointer_grab_events = event_mask;
_gdk_fb_pointer_grab_cursor = cursor?gdk_cursor_ref(cursor):NULL;
if(cursor)
- gdk_fb_cursor_unhide();
+ gdk_fb_cursor_reset();
return GDK_GRAB_SUCCESS;
}
{
gboolean have_grab_cursor = _gdk_fb_pointer_grab_cursor && 1;
- if(have_grab_cursor)
- gdk_fb_cursor_hide();
-
if(_gdk_fb_pointer_grab_window)
gdk_window_unref(_gdk_fb_pointer_grab_window);
_gdk_fb_pointer_grab_window = NULL;
_gdk_fb_pointer_grab_cursor = NULL;
if(have_grab_cursor)
- gdk_fb_cursor_unhide();
+ gdk_fb_cursor_reset();
}
/*
GDK_SUBSTRUCTURE_MASK, /* GDK_DELETE = 0, */
GDK_STRUCTURE_MASK, /* GDK_DESTROY = 1, */
GDK_EXPOSURE_MASK, /* GDK_EXPOSE = 2, */
- GDK_POINTER_MOTION_MASK|GDK_BUTTON_MOTION_MASK, /* GDK_MOTION_NOTIFY = 3, */
+ GDK_POINTER_MOTION_MASK, /* GDK_MOTION_NOTIFY = 3, */
GDK_BUTTON_PRESS_MASK, /* GDK_BUTTON_PRESS = 4, */
GDK_BUTTON_PRESS_MASK, /* GDK_2BUTTON_PRESS = 5, */
GDK_BUTTON_PRESS_MASK, /* GDK_3BUTTON_PRESS = 6, */
GDK_EXPOSURE_MASK, /* GDK_NO_EXPOSE = 30, */
GDK_SCROLL_MASK /* GDK_SCROLL = 31 */
};
+ guint evmask;
+ evmask = GDK_WINDOW_IMPL_FBDATA(window)->event_mask;
+
+ if(evmask & GDK_BUTTON_MOTION_MASK)
+ {
+ evmask |= GDK_BUTTON1_MOTION_MASK|GDK_BUTTON2_MOTION_MASK|GDK_BUTTON3_MOTION_MASK;
+ }
- if(GDK_WINDOW_FBDATA(window)->event_mask & type_masks[type])
+ if(evmask & (GDK_BUTTON1_MOTION_MASK|GDK_BUTTON2_MOTION_MASK|GDK_BUTTON3_MOTION_MASK))
+ {
+ gint x, y;
+ GdkModifierType mask;
+
+ gdk_input_ps2_get_mouseinfo(&x, &y, &mask);
+
+ if(((mask & GDK_BUTTON1_MASK) && (evmask & GDK_BUTTON1_MOTION_MASK))
+ || ((mask & GDK_BUTTON2_MASK) && (evmask & GDK_BUTTON2_MOTION_MASK))
+ || ((mask & GDK_BUTTON3_MASK) && (evmask & GDK_BUTTON3_MOTION_MASK)))
+ evmask |= GDK_POINTER_MOTION_MASK;
+ }
+
+ if(evmask & type_masks[type])
{
GdkEvent *event = gdk_event_new();
- guint32 the_time = g_latest_time.tv_sec;
+ guint32 the_time = g_latest_time.tv_sec * 1000 + g_latest_time.tv_usec / 1000;
event->any.type = type;
event->any.window = gdk_window_ref(window);
+ event->any.send_event = FALSE;
switch(type)
{
case GDK_MOTION_NOTIFY:
event->motion.time = the_time;
+ event->motion.axes = NULL;
break;
case GDK_BUTTON_PRESS:
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
case GDK_BUTTON_RELEASE:
event->button.time = the_time;
+ event->button.axes = NULL;
break;
case GDK_KEY_PRESS:
case GDK_KEY_RELEASE:
gpointer arry[256];
int i;
+ return;
+
free(mymem);
for(i = 0; i < sizeof(arry)/sizeof(arry[0]); i++)
if(!GDK_PIXMAP_FBDATA(d)->no_free_mem)
{
guchar *oldmem = GDK_DRAWABLE_FBDATA(d)->mem;
- guint len = ((GDK_DRAWABLE_P(d)->width * GDK_DRAWABLE_P(d)->depth + 7) / 8) * GDK_DRAWABLE_P(d)->height;
- GDK_DRAWABLE_FBDATA(d)->mem = g_malloc(len);
- memcpy(GDK_DRAWABLE_FBDATA(d)->mem, oldmem, len);
+ guint len = ((GDK_DRAWABLE_IMPL_FBDATA(d)->width * GDK_DRAWABLE_IMPL_FBDATA(d)->depth + 7) / 8) * GDK_DRAWABLE_IMPL_FBDATA(d)->height;
+ GDK_DRAWABLE_IMPL_FBDATA(d)->mem = g_malloc(len);
+ memcpy(GDK_DRAWABLE_IMPL_FBDATA(d)->mem, oldmem, len);
g_free(oldmem);
}
}
#include <pango/pango-modules.h>
#include <freetype/freetype.h>
+#include <freetype/ftglyph.h>
#include <freetype/ftgrays.h>
#if !defined(FREETYPE_MAJOR) || FREETYPE_MAJOR != 2
#error "We need Freetype 2.0 (beta?)"
FT_Library gdk_fb_ft_lib = NULL;
+#define USE_FTGRAYS
+
void
gdk_fb_font_init(void)
{
FT_Init_FreeType(&gdk_fb_ft_lib);
-#if 0
+#ifdef USE_FTGRAYS
FT_Set_Raster(gdk_fb_ft_lib, &ft_grays_raster); /* If this is removed, also turn off USE_FTGRAYS define in gdkdrawable-fb2.c */
#endif
}
FT_Done_FreeType(gdk_fb_ft_lib);
}
+void pango_fb_font_set_size(PangoFont *font);
+
static void pango_fb_font_map_init(PangoFBFontMap *fontmap);
static PangoFont *pango_fb_font_map_load_font(PangoFontMap *fontmap,
const PangoFontDescription *desc);
{
ec = FT_New_Face(gdk_fb_ft_lib, buf, i, &ftf);
if(ec)
- continue; /* error opening */
+ break; /* error opening */
FT_Select_Charmap(ftf, ft_encoding_unicode);
{
g_warning("No family/style on %s", buf);
FT_Done_Face(ftf);
- i = n;
- continue;
+ break;
}
- g_message("Typeface %s/%s", ftf->family_name, ftf->style_name);
pfd = g_new0(PangoFBFontListing, 1);
/* Now add the item */
- pfd->desc.family_name = g_strdup(ftf->family_name);
+ if(ftf->family_name[0] == '/')
+ pfd->desc.family_name = g_strdup(ftf->family_name+1);
+ else
+ pfd->desc.family_name = g_strdup(ftf->family_name);
pfd->desc.style = PANGO_STYLE_NORMAL;
pfd->desc.variant = PANGO_VARIANT_NORMAL;
i++;
}
}
+
+ closedir(dirh);
}
static guint
pango_fb_font_init (PangoFBFont *font)
{
font->desc.size = -1;
- font->extents = g_hash_table_new(NULL, NULL);
+ font->glyph_info = g_hash_table_new(NULL, NULL);
}
static gboolean
g_free_2(gpointer key, gpointer value, gpointer data)
{
+ PangoFBGlyphInfo *pgi = value;
+ g_free(pgi->fbd.drawable_data.mem);
g_free(value);
return TRUE;
}
static void
pango_fb_font_clear_extent_cache(PangoFBFont *fbf)
{
- g_hash_table_foreach_remove(fbf->extents, g_free_2, NULL);
+ g_hash_table_foreach_remove(fbf->glyph_info, g_free_2, NULL);
+}
+
+PangoFBGlyphInfo *
+pango_fb_font_get_glyph_info(PangoFont *font, PangoGlyph glyph)
+{
+ PangoFBGlyphInfo *pgi;
+ PangoFBFont *fbf = PANGO_FB_FONT(font);
+ FT_Bitmap *renderme;
+ FT_GlyphSlot g;
+ PangoRectangle *my_logical_rect, *my_ink_rect;
+ FT_Face ftf;
+
+ ftf = fbf->ftf;
+
+ pango_fb_font_set_size(font);
+
+ pgi = g_hash_table_lookup(fbf->glyph_info, GUINT_TO_POINTER(glyph));
+ if(pgi)
+ return pgi;
+
+ pgi = g_new0(PangoFBGlyphInfo, 1);
+
+ FT_Load_Glyph(ftf, glyph, FT_LOAD_DEFAULT);
+
+ g = ftf->glyph;
+
+ if(g->format != ft_glyph_format_bitmap)
+ {
+ FT_BitmapGlyph bgy;
+ int bdepth;
+
+#if defined(USE_AA) || 1
+#ifdef USE_FTGRAYS
+ bdepth = 256;
+#else
+ bdepth = 128;
+#endif
+#else
+ bdepth = 0;
+#endif
+
+ if(FT_Get_Glyph_Bitmap(ftf, glyph, 0, bdepth, NULL, &bgy))
+ g_error("Glyph render failed");
+
+ renderme = &bgy->bitmap;
+ }
+ else
+ renderme = &g->bitmap;
+
+ pgi->fbd.drawable_data.mem = g_memdup(renderme->buffer, renderme->pitch * renderme->rows);
+ pgi->fbd.drawable_data.rowstride = renderme->pitch;
+ pgi->fbd.drawable_data.width = pgi->fbd.drawable_data.lim_x = renderme->width;
+ pgi->fbd.drawable_data.height = pgi->fbd.drawable_data.lim_y = renderme->rows;
+
+ switch(renderme->pixel_mode)
+ {
+ case ft_pixel_mode_mono:
+ pgi->fbd.drawable_data.depth = 1;
+ break;
+ case ft_pixel_mode_grays:
+#if defined(USE_FTGRAYS)
+ pgi->fbd.drawable_data.depth = 78;
+#else
+ pgi->fbd.drawable_data.depth = 77;
+#endif
+ break;
+ default:
+ g_assert_not_reached();
+ break;
+ }
+
+ my_ink_rect = &pgi->extents[0];
+ my_logical_rect = &pgi->extents[1];
+
+ {
+ my_ink_rect->width = (PANGO_SCALE * g->metrics.width) >> 6;
+ my_ink_rect->height = (PANGO_SCALE * g->metrics.height) >> 6;
+ my_ink_rect->x = - ((PANGO_SCALE * g->metrics.horiBearingX) >> 6);
+ my_ink_rect->y = - ((PANGO_SCALE * g->metrics.horiBearingY) >> 6);
+ }
+
+ {
+ my_logical_rect->width = (PANGO_SCALE * g->metrics.horiAdvance) >> 6;
+ my_logical_rect->height = (PANGO_SCALE * ftf->size->metrics.height) >> 6;
+ my_logical_rect->x = - ((PANGO_SCALE * g->metrics.horiBearingX) >> 6);
+ my_logical_rect->y = - ((PANGO_SCALE * ftf->size->metrics.ascender) >> 6);
+ }
+
+ pgi->hbearing = ((-g->metrics.horiBearingY) >> 6);
+
+ g_hash_table_insert(fbf->glyph_info, GUINT_TO_POINTER(glyph), pgi);
+
+ return pgi;
}
-
static void pango_fb_font_finalize (GObject *object)
{
pango_coverage_unref(fbf->coverage);
g_free(fbf->desc.family_name);
pango_fb_font_clear_extent_cache(fbf);
- g_hash_table_destroy(fbf->extents);
+ g_hash_table_destroy(fbf->glyph_info);
}
static void
PangoRectangle *ink_rect,
PangoRectangle *logical_rect)
{
- FT_Face ftf;
PangoFBFont *fbf;
- PangoRectangle *my_extents, *my_logical_rect, *my_ink_rect;
- FT_GlyphSlot gs;
+ PangoRectangle *my_extents;
+ PangoFBGlyphInfo *gi;
fbf = PANGO_FB_FONT(font);
pango_fb_font_set_size(font);
- my_extents = g_hash_table_lookup(fbf->extents, GUINT_TO_POINTER(glyph));
- if(my_extents)
- goto out;
-
- if(!strcmp(fbf->desc.family_name, "Bitstream Charter"))
- G_BREAKPOINT();
-
- ftf = fbf->ftf;
- if(FT_Load_Glyph(ftf, glyph, FT_LOAD_DEFAULT))
- {
- if(ink_rect)
- memset(ink_rect, 0, sizeof(*ink_rect));
- if(logical_rect)
- memset(logical_rect, 0, sizeof(*logical_rect));
+ gi = pango_fb_font_get_glyph_info(font, glyph);
+ my_extents = gi->extents;
- return;
- }
-
- gs = ftf->glyph;
-
- my_extents = g_new(PangoRectangle, 2);
- my_ink_rect = my_extents;
- my_logical_rect = my_extents + 1;
-
- {
- my_ink_rect->width = (PANGO_SCALE * gs->metrics.width) >> 6;
- my_ink_rect->height = (PANGO_SCALE * gs->metrics.height) >> 6;
- my_ink_rect->x = - ((PANGO_SCALE * gs->metrics.horiBearingX) >> 6);
- my_ink_rect->y = - ((PANGO_SCALE * gs->metrics.horiBearingY) >> 6);
- }
-
- {
- my_logical_rect->width = (PANGO_SCALE * gs->metrics.horiAdvance) >> 6;
- my_logical_rect->height = (PANGO_SCALE * ftf->size->metrics.height) >> 6;
- my_logical_rect->x = - ((PANGO_SCALE * gs->metrics.horiBearingX) >> 6);
- my_logical_rect->y = - ((PANGO_SCALE * ftf->size->metrics.ascender) >> 6);
- }
-
- g_hash_table_insert(fbf->extents, GUINT_TO_POINTER(glyph), my_extents);
-
- out:
if(ink_rect)
*ink_rect = my_extents[0];
gulong pixels[1];
} _GdkPixmapInfo;
+static gpointer parent_class = NULL;
+
+static void
+gdk_pixmap_impl_fb_init (GdkPixmapFBData *impl)
+{
+ GdkDrawableFBData *private = (GdkDrawableFBData *)impl;
+
+ private->window_type = GDK_DRAWABLE_PIXMAP;
+ private->colormap = gdk_colormap_ref(gdk_colormap_get_system());
+ private->mem = NULL;
+ private->width = 1;
+ private->height = 1;
+}
+
static void
-gdk_fb_pixmap_destroy (GdkPixmap *pixmap)
+gdk_pixmap_impl_fb_finalize (GObject *object)
{
- g_free (GDK_DRAWABLE_FBDATA(pixmap)->mem);
- g_free (GDK_DRAWABLE_FBDATA (pixmap));
+ g_free (GDK_DRAWABLE_FBDATA (object)->mem);
+
+ G_OBJECT_CLASS (parent_class)->finalize (object);
}
-static GdkDrawable *
-gdk_fb_pixmap_alloc (void)
+static void
+gdk_pixmap_impl_fb_class_init (GdkPixmapFBClass *klass)
{
- GdkDrawable *drawable;
- GdkDrawablePrivate *private;
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+ // GdkDrawableClass *drawable_class = GDK_DRAWABLE_CLASS (klass);
- static GdkDrawableClass klass;
- static gboolean initialized = FALSE;
+ parent_class = g_type_class_peek_parent (klass);
+
+ object_class->finalize = gdk_pixmap_impl_fb_finalize;
+}
- if (!initialized)
+GType
+_gdk_pixmap_impl_get_type (void)
+{
+ static GType object_type = 0;
+
+ if (!object_type)
{
- initialized = TRUE;
+ static const GTypeInfo object_info =
+ {
+ sizeof (GdkPixmapFBClass),
+ (GBaseInitFunc) NULL,
+ (GBaseFinalizeFunc) NULL,
+ (GClassInitFunc) gdk_pixmap_impl_fb_class_init,
+ NULL, /* class_finalize */
+ NULL, /* class_data */
+ sizeof (GdkPixmapFBData),
+ 0, /* n_preallocs */
+ (GInstanceInitFunc) gdk_pixmap_impl_fb_init
+ };
- klass = _gdk_fb_drawable_class;
- klass.destroy = gdk_fb_pixmap_destroy;
+ object_type = g_type_register_static (gdk_drawable_impl_fb_get_type(),
+ "GdkPixmapFB",
+ &object_info);
}
-
- drawable = gdk_drawable_alloc ();
- private = (GdkDrawablePrivate *)drawable;
-
- private->klass = &klass;
- private->klass_data = g_new0 (GdkDrawableFBData, 1);
- private->window_type = GDK_DRAWABLE_PIXMAP;
- private->colormap = gdk_colormap_ref(gdk_colormap_get_system());
- GDK_DRAWABLE_FBDATA(private)->mem = NULL;
-
- return drawable;
+
+ return object_type;
}
GdkPixmap*
gint depth)
{
GdkPixmap *pixmap;
- GdkDrawablePrivate *private;
+ GdkDrawableFBData *private;
g_return_val_if_fail (window == NULL || GDK_IS_WINDOW (window), NULL);
g_return_val_if_fail ((window != NULL) || (depth != -1), NULL);
if (!window)
window = gdk_parent_root;
- if (GDK_DRAWABLE_DESTROYED (window))
- return NULL;
-
if (depth == -1)
depth = gdk_drawable_get_visual (window)->depth;
- pixmap = gdk_fb_pixmap_alloc ();
- private = (GdkDrawablePrivate *)pixmap;
+ pixmap = (GdkPixmap *)g_type_create_instance(gdk_pixmap_get_type());
+ private = GDK_DRAWABLE_IMPL_FBDATA(pixmap);
- GDK_DRAWABLE_FBDATA(pixmap)->mem = g_malloc(((width * depth + 7) / 8) * height);
- GDK_DRAWABLE_FBDATA(pixmap)->rowstride = (width * depth + 7) / 8; /* Round up to nearest whole byte */
- GDK_DRAWABLE_FBDATA(pixmap)->lim_x = width;
- GDK_DRAWABLE_FBDATA(pixmap)->lim_y = height;
+ GDK_DRAWABLE_IMPL_FBDATA(pixmap)->mem = g_malloc(((width * depth + 7) / 8) * height);
+ GDK_DRAWABLE_IMPL_FBDATA(pixmap)->rowstride = (width * depth + 7) / 8; /* Round up to nearest whole byte */
+ GDK_DRAWABLE_IMPL_FBDATA(pixmap)->lim_x = width;
+ GDK_DRAWABLE_IMPL_FBDATA(pixmap)->lim_y = height;
private->width = width;
private->height = height;
- private->depth = depth;
+ private->depth = ((GdkPixmapObject *)pixmap)->depth = depth;
return pixmap;
}
if (!window)
window = gdk_parent_root;
- if (GDK_DRAWABLE_DESTROYED (window))
- return NULL;
-
pixmap = gdk_pixmap_new(window, width, height, 1);
- memcpy(GDK_DRAWABLE_FBDATA(pixmap)->mem, data, ((width + 7) / 8) * height);
+ memcpy(GDK_DRAWABLE_IMPL_FBDATA(pixmap)->mem, data, ((width + 7) / 8) * height);
return pixmap;
}
GdkColor *bg)
{
GdkPixmap *pixmap;
- GdkDrawablePrivate *private;
g_return_val_if_fail (window == NULL || GDK_IS_WINDOW (window), NULL);
g_return_val_if_fail (data != NULL, NULL);
if (!window)
window = gdk_parent_root;
- if (GDK_DRAWABLE_DESTROYED (window))
- return NULL;
-
if (depth == -1)
depth = gdk_drawable_get_visual (window)->depth;
pixmap = gdk_pixmap_new(window, width, height, depth);
- private = (GdkDrawablePrivate *)pixmap;
-
+ memcpy(GDK_DRAWABLE_IMPL_FBDATA(pixmap)->mem, data, height * GDK_DRAWABLE_IMPL_FBDATA(pixmap)->rowstride);
return pixmap;
}
-
-static gint
-gdk_pixmap_seek_string (FILE *infile,
- const gchar *str,
- gint skip_comments)
-{
- char instr[1024];
-
- while (!feof (infile))
- {
- fscanf (infile, "%1023s", instr);
- if (skip_comments == TRUE && strcmp (instr, "/*") == 0)
- {
- fscanf (infile, "%1023s", instr);
- while (!feof (infile) && strcmp (instr, "*/") != 0)
- fscanf (infile, "%1023s", instr);
- fscanf(infile, "%1023s", instr);
- }
- if (strcmp (instr, str)==0)
- return TRUE;
- }
-
- return FALSE;
-}
-
-static gint
-gdk_pixmap_seek_char (FILE *infile,
- gchar c)
-{
- gint b, oldb;
-
- while ((b = getc(infile)) != EOF)
- {
- if (c != b && b == '/')
- {
- b = getc (infile);
- if (b == EOF)
- return FALSE;
- else if (b == '*') /* we have a comment */
- {
- b = -1;
- do
- {
- oldb = b;
- b = getc (infile);
- if (b == EOF)
- return FALSE;
- }
- while (!(oldb == '*' && b == '/'));
- }
- }
- else if (c == b)
- return TRUE;
- }
- return FALSE;
-}
-
-static gint
-gdk_pixmap_read_string (FILE *infile,
- gchar **buffer,
- guint *buffer_size)
-{
- gint c;
- guint cnt = 0, bufsiz, ret = FALSE;
- gchar *buf;
-
- buf = *buffer;
- bufsiz = *buffer_size;
- if (buf == NULL)
- {
- bufsiz = 10 * sizeof (gchar);
- buf = g_new(gchar, bufsiz);
- }
-
- do
- c = getc (infile);
- while (c != EOF && c != '"');
-
- if (c != '"')
- goto out;
-
- while ((c = getc(infile)) != EOF)
- {
- if (cnt == bufsiz)
- {
- guint new_size = bufsiz * 2;
- if (new_size > bufsiz)
- bufsiz = new_size;
- else
- goto out;
-
- buf = (gchar *) g_realloc (buf, bufsiz);
- buf[bufsiz-1] = '\0';
- }
-
- if (c != '"')
- buf[cnt++] = c;
- else
- {
- buf[cnt] = 0;
- ret = TRUE;
- break;
- }
- }
-
- out:
- buf[bufsiz-1] = '\0'; /* ensure null termination for errors */
- *buffer = buf;
- *buffer_size = bufsiz;
- return ret;
-}
-
-static gchar*
-gdk_pixmap_skip_whitespaces (gchar *buffer)
-{
- gint32 index = 0;
-
- while (buffer[index] != 0 && (buffer[index] == 0x20 || buffer[index] == 0x09))
- index++;
-
- return &buffer[index];
-}
-
-static gchar*
-gdk_pixmap_skip_string (gchar *buffer)
-{
- gint32 index = 0;
-
- while (buffer[index] != 0 && buffer[index] != 0x20 && buffer[index] != 0x09)
- index++;
-
- return &buffer[index];
-}
-
-/* Xlib crashed once at a color name lengths around 125 */
-#define MAX_COLOR_LEN 120
-
-static gchar*
-gdk_pixmap_extract_color (gchar *buffer)
-{
- gint counter, numnames;
- gchar *ptr = NULL, ch, temp[128];
- gchar color[MAX_COLOR_LEN], *retcol;
- gint space;
-
- counter = 0;
- while (ptr == NULL)
- {
- if (buffer[counter] == 'c')
- {
- ch = buffer[counter + 1];
- if (ch == 0x20 || ch == 0x09)
- ptr = &buffer[counter + 1];
- }
- else if (buffer[counter] == 0)
- return NULL;
-
- counter++;
- }
-
- ptr = gdk_pixmap_skip_whitespaces (ptr);
-
- if (ptr[0] == 0)
- return NULL;
- else if (ptr[0] == '#')
- {
- counter = 1;
- while (ptr[counter] != 0 &&
- ((ptr[counter] >= '0' && ptr[counter] <= '9') ||
- (ptr[counter] >= 'a' && ptr[counter] <= 'f') ||
- (ptr[counter] >= 'A' && ptr[counter] <= 'F')))
- counter++;
-
- retcol = g_new (gchar, counter+1);
- strncpy (retcol, ptr, counter);
-
- retcol[counter] = 0;
-
- return retcol;
- }
-
- color[0] = 0;
- numnames = 0;
-
- space = MAX_COLOR_LEN - 1;
- while (space > 0)
- {
- sscanf (ptr, "%127s", temp);
-
- if (((gint)ptr[0] == 0) ||
- (strcmp ("s", temp) == 0) || (strcmp ("m", temp) == 0) ||
- (strcmp ("g", temp) == 0) || (strcmp ("g4", temp) == 0))
- {
- break;
- }
- else
- {
- if (numnames > 0)
- {
- space -= 1;
- strcat (color, " ");
- }
- strncat (color, temp, space);
- space -= MIN (space, strlen (temp));
- ptr = gdk_pixmap_skip_string (ptr);
- ptr = gdk_pixmap_skip_whitespaces (ptr);
- numnames++;
- }
- }
-
- retcol = g_strdup (color);
- return retcol;
-}
-
-
-enum buffer_op
-{
- op_header,
- op_cmap,
- op_body
-};
-
-
-static void
-gdk_xpm_destroy_notify (gpointer data)
-{
- _GdkPixmapInfo *info = (_GdkPixmapInfo *)data;
- GdkColor color;
- int i;
-
- for (i=0; i<info->ncolors; i++)
- {
- color.pixel = info->pixels[i];
- gdk_colormap_free_colors (info->colormap, &color, 1);
- }
-
- gdk_colormap_unref (info->colormap);
- g_free (info);
-}
-
-static GdkPixmap *
-_gdk_pixmap_create_from_xpm (GdkWindow *window,
- GdkColormap *colormap,
- GdkBitmap **mask,
- GdkColor *transparent_color,
- gchar * (*get_buf) (enum buffer_op op,
- gpointer handle),
- gpointer handle)
-{
- GdkPixmap *pixmap = NULL;
- GdkImage *image = NULL;
- GdkVisual *visual;
- GdkGC *gc = NULL;
- GdkColor tmp_color;
- gint width, height, num_cols, cpp, n, ns, cnt, xcnt, ycnt, wbytes;
- gchar *buffer, pixel_str[32];
- gchar *name_buf;
- _GdkPixmapColor *color = NULL, *fallbackcolor = NULL;
- _GdkPixmapColor *colors = NULL;
- gulong index;
- GHashTable *color_hash = NULL;
- _GdkPixmapInfo *color_info = NULL;
-
- if ((window == NULL) && (colormap == NULL))
- g_warning ("Creating pixmap from xpm with NULL window and colormap");
-
- if (window == NULL)
- window = gdk_parent_root;
-
- if (colormap == NULL)
- {
- colormap = gdk_drawable_get_colormap (window);
- visual = gdk_drawable_get_visual (window);
- }
- else
- visual = ((GdkColormapPrivate *)colormap)->visual;
-
- buffer = (*get_buf) (op_header, handle);
- if (buffer == NULL)
- return NULL;
-
- sscanf (buffer,"%d %d %d %d", &width, &height, &num_cols, &cpp);
- if (cpp >= 32)
- {
- g_warning ("Pixmap has more than 31 characters per color\n");
- return NULL;
- }
-
- color_hash = g_hash_table_new (g_str_hash, g_str_equal);
-
- if (transparent_color == NULL)
- {
- gdk_color_white (colormap, &tmp_color);
- transparent_color = &tmp_color;
- }
-
- /* For pseudo-color and grayscale visuals, we have to remember
- * the colors we allocated, so we can free them later.
- */
- if ((visual->type == GDK_VISUAL_PSEUDO_COLOR) ||
- (visual->type == GDK_VISUAL_GRAYSCALE))
- {
- color_info = g_malloc (sizeof (_GdkPixmapInfo) +
- sizeof(gulong) * (num_cols - 1));
- color_info->ncolors = num_cols;
- color_info->colormap = colormap;
- gdk_colormap_ref (colormap);
- }
-
- name_buf = g_new (gchar, num_cols * (cpp+1));
- colors = g_new (_GdkPixmapColor, num_cols);
-
- for (cnt = 0; cnt < num_cols; cnt++)
- {
- gchar *color_name;
-
- buffer = (*get_buf) (op_cmap, handle);
- if (buffer == NULL)
- goto error;
-
- color = &colors[cnt];
- color->color_string = &name_buf [cnt * (cpp + 1)];
- strncpy (color->color_string, buffer, cpp);
- color->color_string[cpp] = 0;
- buffer += strlen (color->color_string);
- color->transparent = FALSE;
-
- color_name = gdk_pixmap_extract_color (buffer);
-
- if (color_name == NULL || g_strcasecmp (color_name, "None") == 0 ||
- gdk_color_parse (color_name, &color->color) == FALSE)
- {
- color->color = *transparent_color;
- color->transparent = TRUE;
- }
-
- g_free (color_name);
-
- /* FIXME: The remaining slowness appears to happen in this
- function. */
- gdk_color_alloc (colormap, &color->color);
-
- if (color_info)
- color_info->pixels[cnt] = color->color.pixel;
-
- g_hash_table_insert (color_hash, color->color_string, color);
- if (cnt == 0)
- fallbackcolor = color;
- }
-
- index = 0;
- image = gdk_image_new (GDK_IMAGE_FASTEST, visual, width, height);
-
- if (mask)
- {
- /* The pixmap mask is just a bits pattern.
- * Color 0 is used for background and 1 for foreground.
- * We don't care about the colormap, we just need 0 and 1.
- */
- GdkColor mask_pattern;
-
- *mask = gdk_pixmap_new (window, width, height, 1);
- gc = gdk_gc_new (*mask);
-
- mask_pattern.pixel = 0;
- gdk_gc_set_foreground (gc, &mask_pattern);
- gdk_draw_rectangle (*mask, gc, TRUE, 0, 0, width, height);
-
- mask_pattern.pixel = 255;
- gdk_gc_set_foreground (gc, &mask_pattern);
- }
-
- wbytes = width * cpp;
- for (ycnt = 0; ycnt < height; ycnt++)
- {
- buffer = (*get_buf) (op_body, handle);
-
- /* FIXME: this slows things down a little - it could be
- * integrated into the strncpy below, perhaps. OTOH, strlen
- * is fast.
- */
- if ((buffer == NULL) || strlen (buffer) < wbytes)
- continue;
-
- for (n = 0, cnt = 0, xcnt = 0; n < wbytes; n += cpp, xcnt++)
- {
- strncpy (pixel_str, &buffer[n], cpp);
- pixel_str[cpp] = 0;
- ns = 0;
-
- color = g_hash_table_lookup (color_hash, pixel_str);
-
- if (!color) /* screwed up XPM file */
- color = fallbackcolor;
-
- gdk_image_put_pixel (image, xcnt, ycnt, color->color.pixel);
-
- if (mask && color->transparent)
- {
- if (cnt < xcnt)
- gdk_draw_line (*mask, gc, cnt, ycnt, xcnt - 1, ycnt);
- cnt = xcnt + 1;
- }
- }
-
- if (mask && (cnt < xcnt))
- gdk_draw_line (*mask, gc, cnt, ycnt, xcnt - 1, ycnt);
- }
-
- error:
-
- if (mask)
- gdk_gc_unref (gc);
-
- if (image != NULL)
- {
- pixmap = gdk_pixmap_new (window, width, height, visual->depth);
-
- if (color_info)
- gdk_drawable_set_data (pixmap, "gdk-xpm", color_info,
- gdk_xpm_destroy_notify);
-
- gc = gdk_gc_new (pixmap);
- gdk_gc_set_foreground (gc, transparent_color);
- gdk_draw_image (pixmap, gc, image, 0, 0, 0, 0, image->width, image->height);
- gdk_gc_unref (gc);
- gdk_image_unref (image);
-
-#if 0
- g_print("%dx%d\n", width, height);
- for(y = 0; y < height; y++)
- {
- for(x = 0; x < width; x++)
- {
- guchar foo = GDK_DRAWABLE_FBDATA(pixmap)->mem[(x + GDK_DRAWABLE_FBDATA(pixmap)->rowstride * y];
- if(foo == 0)
- g_print("o");
- else if(foo == 255)
- g_print("w");
- else if(foo == transparent_color->pixel)
- g_print(" ");
- else
- g_print(".");
- }
- g_print("\n");
- }
-#endif
- }
- else if (color_info)
- gdk_xpm_destroy_notify (color_info);
-
- if (color_hash != NULL)
- g_hash_table_destroy (color_hash);
-
- if (colors != NULL)
- g_free (colors);
-
- if (name_buf != NULL)
- g_free (name_buf);
-
- return pixmap;
-}
-
-
-struct file_handle
-{
- FILE *infile;
- gchar *buffer;
- guint buffer_size;
-};
-
-
-static gchar *
-file_buffer (enum buffer_op op, gpointer handle)
-{
- struct file_handle *h = handle;
-
- switch (op)
- {
- case op_header:
- if (gdk_pixmap_seek_string (h->infile, "XPM", FALSE) != TRUE)
- break;
-
- if (gdk_pixmap_seek_char (h->infile,'{') != TRUE)
- break;
- /* Fall through to the next gdk_pixmap_seek_char. */
-
- case op_cmap:
- gdk_pixmap_seek_char (h->infile, '"');
- fseek (h->infile, -1, SEEK_CUR);
- /* Fall through to the gdk_pixmap_read_string. */
-
- case op_body:
- gdk_pixmap_read_string (h->infile, &h->buffer, &h->buffer_size);
- return h->buffer;
- }
- return 0;
-}
-
-
-GdkPixmap*
-gdk_pixmap_colormap_create_from_xpm (GdkWindow *window,
- GdkColormap *colormap,
- GdkBitmap **mask,
- GdkColor *transparent_color,
- const gchar *filename)
-{
- struct file_handle h;
- GdkPixmap *pixmap = NULL;
-
- memset (&h, 0, sizeof (h));
- h.infile = fopen (filename, "rb");
- if (h.infile != NULL)
- {
- pixmap = _gdk_pixmap_create_from_xpm (window, colormap, mask,
- transparent_color,
- file_buffer, &h);
- fclose (h.infile);
- g_free (h.buffer);
- }
-
- return pixmap;
-}
-
-GdkPixmap*
-gdk_pixmap_create_from_xpm (GdkWindow *window,
- GdkBitmap **mask,
- GdkColor *transparent_color,
- const gchar *filename)
-{
- return gdk_pixmap_colormap_create_from_xpm (window, NULL, mask,
- transparent_color, filename);
-}
-
-
-struct mem_handle
-{
- gchar **data;
- int offset;
-};
-
-
-static gchar *
-mem_buffer (enum buffer_op op, gpointer handle)
-{
- struct mem_handle *h = handle;
- switch (op)
- {
- case op_header:
- case op_cmap:
- case op_body:
- if (h->data[h->offset])
- return h->data[h->offset ++];
- }
- return 0;
-}
-
-
-GdkPixmap*
-gdk_pixmap_colormap_create_from_xpm_d (GdkWindow *window,
- GdkColormap *colormap,
- GdkBitmap **mask,
- GdkColor *transparent_color,
- gchar **data)
-{
- struct mem_handle h;
- GdkPixmap *pixmap = NULL;
-
- memset (&h, 0, sizeof (h));
- h.data = data;
- pixmap = _gdk_pixmap_create_from_xpm (window, colormap, mask,
- transparent_color,
- mem_buffer, &h);
- return pixmap;
-}
-
-
-GdkPixmap*
-gdk_pixmap_create_from_xpm_d (GdkWindow *window,
- GdkBitmap **mask,
- GdkColor *transparent_color,
- gchar **data)
-{
- return gdk_pixmap_colormap_create_from_xpm_d (window, NULL, mask,
- transparent_color, data);
-}
#include <stdio.h>
#include <freetype/freetype.h>
-#define GDK_DRAWABLE_FBDATA(win) ((GdkDrawableFBData *)(((GdkDrawablePrivate*)(win))->klass_data))
-#define GDK_PIXMAP_FBDATA(win) ((GdkPixmapFBData *)(((GdkDrawablePrivate*)(win))->klass_data))
-#define GDK_WINDOW_FBDATA(win) ((GdkWindowFBData *)(((GdkDrawablePrivate*)(win))->klass_data))
+#define GDK_DRAWABLE_IMPL_FBDATA(win) ((GdkDrawableFBData *)((GdkWindowPrivate *)(win))->impl)
+#define GDK_DRAWABLE_IMPL(win) ((GdkDrawable *)((GdkWindowPrivate *)(win))->impl)
+#define GDK_WINDOW_IMPL_FBDATA(win) ((GdkWindowFBData *)((GdkWindowPrivate *)(win))->impl)
+#define GDK_PIXMAP_IMPL_FBDATA(win) ((GdkPixmapFBData *)((GdkWindowPrivate *)(win))->impl)
+#define GDK_DRAWABLE_FBDATA(win) ((GdkDrawableFBData *)(win))
+#define GDK_PIXMAP_FBDATA(win) ((GdkPixmapFBData *)(win))
+#define GDK_WINDOW_FBDATA(win) ((GdkWindowFBData *)(win))
#define GDK_FONT_FB(f) ((GdkFontPrivateFB *)(f))
#define GDK_CURSOR_FB(c) ((GdkCursorPrivateFB *)(c))
+#define GDK_CHECK_IMPL(drawable) \
+ g_assert(G_OBJECT_TYPE(drawable) == _gdk_window_impl_get_type() || G_OBJECT_TYPE(drawable) == _gdk_pixmap_impl_get_type())
+#define GDK_CHECK_INTF(drawable) \
+ g_assert(G_OBJECT_TYPE(drawable) == gdk_window_get_type() || G_OBJECT_TYPE(drawable) == gdk_pixmap_get_type())
+
typedef struct _GdkDrawableFBData GdkDrawableFBData;
typedef struct _GdkWindowFBData GdkWindowFBData;
typedef struct _GdkPixmapFBData GdkPixmapFBData;
+typedef GdkWindowObject GdkWindowPrivate;
+#define GDK_DRAWABLE_PIXMAP (GDK_WINDOW_FOREIGN+1)
struct _GdkDrawableFBData
{
+ GdkDrawable parent_object;
+
+ GdkDrawable *wrapper;
+
guchar *mem;
gint abs_x, abs_y, lim_x, lim_y, llim_x, llim_y; /* computed values */
guint rowstride;
+
+ /* Due to excursions in gdk, this stuff has to be stored here instead of in GdkDrawable where it belongs */
+ gint width, height, depth;
+ GdkColormap *colormap;
+ GdkWindowType window_type;
};
+typedef struct {
+ GdkDrawableClass base_class;
+} GdkDrawableFBClass;
+
+#define GDK_DRAWABLE_P(x) ((GdkDrawableFBData *)(x))
+
struct _GdkPixmapFBData
{
GdkDrawableFBData drawable_data;
};
+typedef struct {
+ GdkDrawableFBClass klass;
+} GdkPixmapFBClass;
+
+GType gdk_drawable_impl_fb_get_type (void);
+
typedef struct {
gulong length;
GdkAtom type;
gboolean realized : 1;
};
+typedef struct {
+ GdkDrawableFBClass base_class;
+} GdkWindowFBClass;
+#define GDK_WINDOW_P(x) ((GdkWindowObject *)(x))
+
struct _GdkFBDisplay
{
int fd;
} GdkVisualPrivateFB;
typedef struct {
- GdkColormapPrivate base;
+ GdkColormap base;
GHashTable *hash;
GdkColorInfo *info;
guint sync_tag;
} GdkColormapPrivateFB;
+typedef struct {
+ GdkColormapClass base_class;
+} GdkColormapFBClass;
+
typedef struct {
GdkCursor base;
GdkPixmap *cursor, *mask;
int hot_x, hot_y;
+ int mask_off_x, mask_off_y;
} GdkCursorPrivateFB;
typedef struct {
void gdk_fb_font_fini(void);
typedef struct {
- GdkImagePrivate base;
+ GdkImage base;
} GdkImagePrivateFB;
-#define GDK_GC_FBDATA(x) ((GdkGCFBData *)((GdkGCPrivate *)x)->klass_data)
+#define GDK_GC_FBDATA(x) ((GdkGCFBData *)(x))
+#define GDK_GC_P(x) ((GdkGC *)(x))
+
typedef struct {
+ GdkGC parent_instance;
+
GdkRegion *clip_region;
gchar *dash_list;
GdkGCValuesMask values_mask;
guchar depth, alu;
} GdkGCFBData;
+typedef struct {
+ GdkGCClass parent_class;
+} GdkGCFBClass;
+
+GType gdk_gc_fb_get_type (void);
+#if 0
GdkGC * _gdk_fb_gc_new (GdkDrawable *drawable,
GdkGCValues *values,
GdkGCValuesMask values_mask);
+#endif
/* Routines from gdkgeometry-fb.c */
void _gdk_window_process_expose (GdkWindow *window,
gulong serial,
GdkRectangle *area);
+void gdk_window_invalidate_region_clear(GdkWindow *window, GdkRegion *region);
+void gdk_window_invalidate_rect_clear(GdkWindow *window, GdkRectangle *rect);
GdkGC *_gdk_fb_gc_new(GdkDrawable *drawable, GdkGCValues *values, GdkGCValuesMask values_mask);
void gdk_fb_drawable_clear(GdkDrawable *drawable);
gint y,
gint width,
gint height);
-void gdk_fb_fill_spans(GdkDrawable *drawable, GdkGC *gc, GdkRectangle *rects, int nrects);
+void gdk_fb_fill_spans(GdkDrawable *real_drawable, GdkGC *gc, GdkRectangle *rects, int nrects);
+GdkRegion *gdk_fb_clip_region(GdkDrawable *drawable, GdkGC *gc, gboolean do_clipping, gboolean do_children);
extern GdkWindow *_gdk_fb_pointer_grab_window, *_gdk_fb_keyboard_grab_window, *_gdk_fb_pointer_grab_confine;
extern GdkEventMask _gdk_fb_pointer_grab_events, _gdk_fb_keyboard_grab_events;
extern GdkDrawableClass _gdk_fb_drawable_class;
extern FILE *debug_out;
GdkEvent *gdk_event_make(GdkWindow *window, GdkEventType type, gboolean append_to_queue);
+GdkEvent *gdk_event_make_2(GdkWindow *window, GdkEventType type, gboolean append_to_queue, gint button_press_num);
void gdk_fb_get_cursor_rect(GdkRectangle *rect);
+gboolean gdk_fb_cursor_need_hide(GdkRectangle *rect);
+gboolean gdk_fb_cursor_region_need_hide(GdkRegion *region);
void gdk_fb_cursor_unhide(void);
+void gdk_fb_cursor_reset(void);
void gdk_fb_cursor_hide(void);
void gdk_fb_redraw_all(void);
void gdk_input_ps2_get_mouseinfo(gint *x, gint *y, GdkModifierType *mask);
+void gdk_fb_window_visibility_crossing(GdkWindow *window, gboolean is_show);
#define PANGO_TYPE_FB_FONT (pango_fb_font_get_type ())
#define PANGO_FB_FONT(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FB_FONT, PangoFBFont))
FT_Face ftf;
PangoFontDescription desc;
PangoCoverage *coverage;
- GHashTable *extents;
+ GHashTable *glyph_info;
};
+typedef struct {
+ PangoRectangle extents[2];
+ GdkPixmapFBData fbd;
+ int hbearing;
+} PangoFBGlyphInfo;
+
GType pango_fb_font_get_type (void);
gboolean pango_fb_has_glyph(PangoFont *font, PangoGlyph glyph);
PangoGlyph pango_fb_get_unknown_glyph(PangoFont *font);
+PangoFBGlyphInfo *pango_fb_font_get_glyph_info(PangoFont *font, PangoGlyph glyph);
+
+void gdk_fb_window_move_resize (GdkWindow *window,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ gboolean send_expose_events);
extern void CM(void); /* Check for general mem corruption */
extern void RP(GdkDrawable *drawable); /* Same, for pixmaps */
GdkAtom property,
GdkWindowProperty *prop)
{
- GdkWindowFBData *fbd = GDK_WINDOW_FBDATA(window);
+ GdkWindowFBData *fbd = GDK_WINDOW_IMPL_FBDATA(window);
GdkEvent *event;
g_hash_table_remove(fbd->properties, GUINT_TO_POINTER(property));
#include <limits.h>
-GdkDrawableClass _gdk_windowing_window_class;
+static gpointer parent_class = NULL;
static void recompute_drawable(GdkDrawable *drawable);
}
static void
-gdk_fb_window_destroy (GdkDrawable *drawable)
+gdk_window_impl_fb_finalize (GObject *object)
{
- GdkWindowFBData *fbd = GDK_WINDOW_FBDATA(drawable);
+ GdkWindowFBData *fbd = GDK_WINDOW_FBDATA(object);
- if (!GDK_DRAWABLE_DESTROYED (drawable))
- g_warning ("losing last reference to undestroyed window\n");
-
- if(GDK_WINDOW_P(drawable)->mapped)
- gdk_window_hide(drawable);
+ if(GDK_WINDOW_P(fbd->drawable_data.wrapper)->mapped)
+ gdk_window_hide(fbd->drawable_data.wrapper);
if(fbd->cursor)
gdk_cursor_unref(fbd->cursor);
g_hash_table_destroy(fbd->properties);
}
- g_free (GDK_DRAWABLE_FBDATA (drawable));
+ G_OBJECT_CLASS (parent_class)->finalize (object);
}
-static GdkWindow *
-gdk_fb_window_alloc (void)
+static void
+gdk_window_impl_fb_class_init (GdkWindowFBClass *klass)
{
- GdkWindow *window;
- GdkWindowPrivate *private;
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+ // GdkDrawableClass *drawable_class = GDK_DRAWABLE_CLASS (klass);
- static gboolean initialized = FALSE;
-
- if (!initialized)
- {
- initialized = TRUE;
+ parent_class = g_type_class_peek_parent (klass);
- _gdk_windowing_window_class = _gdk_fb_drawable_class;
- _gdk_windowing_window_class.destroy = gdk_fb_window_destroy;
- }
+ object_class->finalize = gdk_window_impl_fb_finalize;
+}
- window = _gdk_window_alloc ();
- private = (GdkWindowPrivate *)window;
+static void
+gdk_window_impl_fb_init (GdkWindowFBData *impl)
+{
+ impl->drawable_data.depth = gdk_display->modeinfo.bits_per_pixel;
+ impl->drawable_data.colormap = gdk_colormap_get_system ();
+ impl->event_mask = GDK_STRUCTURE_MASK;
+}
- private->drawable.klass = &_gdk_window_class;
- private->drawable.klass_data = g_new0 (GdkWindowFBData, 1);
- private->drawable.depth = gdk_display->modeinfo.bits_per_pixel;
- private->drawable.colormap = gdk_colormap_get_system ();
- GDK_WINDOW_FBDATA(private)->event_mask = GDK_STRUCTURE_MASK;
+GType
+_gdk_window_impl_get_type (void)
+{
+ static GType object_type = 0;
- return window;
+ if (!object_type)
+ {
+ static const GTypeInfo object_info =
+ {
+ sizeof (GdkWindowFBClass),
+ (GBaseInitFunc) NULL,
+ (GBaseFinalizeFunc) NULL,
+ (GClassInitFunc) gdk_window_impl_fb_class_init,
+ NULL, /* class_finalize */
+ NULL, /* class_data */
+ sizeof (GdkWindowFBData),
+ 0, /* n_preallocs */
+ (GInstanceInitFunc) gdk_window_impl_fb_init,
+ };
+
+ object_type = g_type_register_static (gdk_drawable_impl_fb_get_type(),
+ "GdkWindowFB",
+ &object_info);
+ }
+
+ return object_type;
}
#include "/usr/include/X11/bitmaps/left_ptr"
#include "/usr/include/X11/bitmaps/left_ptrmsk"
void
-gdk_window_init (void)
+_gdk_windowing_window_init (void)
{
+ GdkWindowAttr attr;
+
GdkBitmap *ptr, *mask;
GdkCursor *cursor;
GdkWindowPrivate *private;
- gdk_parent_root = gdk_fb_window_alloc ();
- private = (GdkWindowPrivate *)gdk_parent_root;
-
- private->drawable.window_type = GDK_WINDOW_ROOT;
- private->drawable.width = gdk_screen_width ();
- private->drawable.height = gdk_screen_height ();
- private->mapped = TRUE;
- private->x = 0;
- private->y = 0;
-
- GDK_DRAWABLE_FBDATA(private)->mem = gdk_display->fbmem;
-#if 0
- GDK_DRAWABLE_FBDATA(private)->rowstride = gdk_display->modeinfo.xres * (gdk_display->modeinfo.bits_per_pixel >> 3);
+ ptr = gdk_bitmap_create_from_data(gdk_parent_root, left_ptr_bits, left_ptr_width, left_ptr_height);
+ mask = gdk_bitmap_create_from_data(gdk_parent_root, left_ptrmsk_bits, left_ptrmsk_width, left_ptrmsk_height);
+#if 1
+ cursor = gdk_cursor_new_from_pixmap(ptr, mask, NULL, NULL, left_ptr_x_hot, left_ptr_y_hot);
#else
- GDK_DRAWABLE_FBDATA(private)->rowstride = gdk_display->sinfo.line_length;
+ cursor = gdk_cursor_new(GDK_LEFT_PTR);
#endif
- GDK_DRAWABLE_FBDATA(private)->lim_x = gdk_display->modeinfo.xres;
- GDK_DRAWABLE_FBDATA(private)->lim_y = gdk_display->modeinfo.yres;
- GDK_WINDOW_FBDATA(private)->event_mask = GDK_EXPOSURE_MASK;
- gdk_fb_drawable_clear(gdk_parent_root);
+ attr.width = gdk_screen_width();
+ attr.height = gdk_screen_height();
+ attr.window_type = GDK_WINDOW_ROOT;
+ attr.cursor = cursor;
+ attr.event_mask = GDK_EXPOSURE_MASK;
+ attr.wclass = GDK_INPUT_OUTPUT;
+ gdk_parent_root = gdk_window_new(NULL, &attr, GDK_WA_CURSOR);
+ private = (GdkWindowPrivate *)gdk_parent_root;
- ptr = gdk_bitmap_create_from_data(gdk_parent_root, left_ptr_bits, left_ptr_width, left_ptr_height);
- mask = gdk_bitmap_create_from_data(gdk_parent_root, left_ptrmsk_bits, left_ptrmsk_width, left_ptrmsk_height);
- cursor = gdk_cursor_new_from_pixmap(ptr, mask, NULL, NULL, left_ptr_x_hot, left_ptr_y_hot);
+ private->mapped = TRUE;
- gdk_window_set_cursor(gdk_parent_root, cursor);
+ GDK_DRAWABLE_IMPL_FBDATA(gdk_parent_root)->lim_x = attr.width;
+ GDK_DRAWABLE_IMPL_FBDATA(gdk_parent_root)->lim_y = attr.height;
+ gdk_fb_drawable_clear(gdk_parent_root);
}
GdkWindow*
GdkWindowPrivate *private;
GdkWindowPrivate *parent_private;
GdkVisual *visual;
+ GdkWindowFBData *impl;
int x, y, depth;
parent = gdk_parent_root;
parent_private = (GdkWindowPrivate*) parent;
- if (GDK_DRAWABLE_DESTROYED (parent))
- return NULL;
- window = gdk_fb_window_alloc ();
- private = (GdkWindowPrivate *)window;
+ window = (GdkWindow *)g_type_create_instance(GDK_TYPE_WINDOW);
+ private = (GdkWindowObject *)window;
- private->parent = parent;
+ private->parent = parent_private;
if (attributes_mask & GDK_WA_X)
x = attributes->x;
if (attributes_mask & GDK_WA_VISUAL)
visual = attributes->visual;
+ else
+ visual = gdk_visual_get_system();
+ impl = (GdkWindowFBData *)private->impl;
+ impl->drawable_data.wrapper = window;
private->x = x;
private->y = y;
- private->drawable.width = (attributes->width > 1) ? (attributes->width) : (1);
- private->drawable.height = (attributes->height > 1) ? (attributes->height) : (1);
- private->drawable.window_type = attributes->window_type;
- GDK_DRAWABLE_FBDATA(private)->mem = gdk_display->fbmem;
- GDK_DRAWABLE_FBDATA(private)->rowstride = GDK_DRAWABLE_FBDATA(gdk_parent_root)->rowstride;
+ impl->drawable_data.width = (attributes->width > 1) ? (attributes->width) : (1);
+ impl->drawable_data.height = (attributes->height > 1) ? (attributes->height) : (1);
+ private->window_type = impl->drawable_data.window_type = attributes->window_type;
+ impl->drawable_data.mem = gdk_display->fbmem;
+ impl->drawable_data.rowstride = gdk_display->sinfo.line_length;
gdk_window_move_resize (window, x, y,
- private->drawable.width, private->drawable.height);
+ impl->drawable_data.width, impl->drawable_data.height);
if (attributes->wclass == GDK_INPUT_OUTPUT)
{
depth = visual->depth;
private->input_only = FALSE;
- private->drawable.depth = depth;
+ private->depth = impl->drawable_data.depth;
if ((attributes_mask & GDK_WA_COLORMAP)
&& attributes->colormap)
- private->drawable.colormap = attributes->colormap;
+ impl->drawable_data.colormap = attributes->colormap;
+ else
+ impl->drawable_data.colormap = gdk_colormap_get_system();
- switch (private->drawable.window_type)
+ switch (impl->drawable_data.window_type)
{
case GDK_WINDOW_TOPLEVEL:
case GDK_WINDOW_CHILD:
case GDK_WINDOW_DIALOG:
case GDK_WINDOW_TEMP:
+ default:
break;
case GDK_WINDOW_ROOT:
- g_error ("cannot make windows of type GDK_WINDOW_ROOT");
+ if(gdk_parent_root)
+ g_error ("cannot make windows of type GDK_WINDOW_ROOT");
break;
- case GDK_WINDOW_PIXMAP:
- g_error ("cannot make windows of type GDK_WINDOW_PIXMAP (use gdk_pixmap_new)");
+ case GDK_DRAWABLE_PIXMAP:
+ g_error ("cannot make windows of type GDK_DRAWABLE_PIXMAP (use gdk_pixmap_new)");
break;
}
}
{
depth = 0;
private->input_only = TRUE;
- GDK_WINDOW_FBDATA(private)->level = 10000;
- private->drawable.colormap = NULL;
+ impl->level = 10000;
+ impl->drawable_data.colormap = NULL;
}
gdk_drawable_ref (window);
- if (private->drawable.colormap)
- gdk_colormap_ref (private->drawable.colormap);
+ if (impl->drawable_data.colormap)
+ gdk_colormap_ref (impl->drawable_data.colormap);
gdk_window_set_cursor (window, ((attributes_mask & GDK_WA_CURSOR) ?
(attributes->cursor) :
NULL));
if (parent_private)
+ {
parent_private->children = g_list_prepend (parent_private->children, window);
- if(parent_private && parent_private->children->next)
- GDK_WINDOW_FBDATA(private)->level = GDK_WINDOW_FBDATA(parent_private->children->next->data)->level + 1;
+ if(parent_private->children->next)
+ impl->level = GDK_WINDOW_FBDATA(GDK_WINDOW_P(parent_private->children->next->data)->impl)->level + 1;
+ }
return window;
}
gboolean recursing,
gboolean foreign_destroy)
{
+#if 0
GdkWindowPrivate *private;
GdkWindowPrivate *temp_private;
GdkWindow *temp_window;
private = (GdkWindowPrivate*) window;
- switch (private->drawable.window_type)
+ switch (private->window_type)
{
case GDK_WINDOW_TOPLEVEL:
case GDK_WINDOW_CHILD:
case GDK_WINDOW_DIALOG:
case GDK_WINDOW_TEMP:
case GDK_WINDOW_FOREIGN:
- if (!private->drawable.destroyed)
+ if (!private->destroyed)
{
if (private->parent)
{
parent_private->children = g_list_remove (parent_private->children, window);
}
- if (private->bg_pixmap && private->bg_pixmap != GDK_PARENT_RELATIVE_BG)
+ if (private->bg_pixmap && private->bg_pixmap != GDK_PARENT_RELATIVE_BG && private->bg_pixmap != GDK_NO_BG)
{
gdk_pixmap_unref (private->bg_pixmap);
private->bg_pixmap = NULL;
}
-
+
if (GDK_DRAWABLE_TYPE (window) != GDK_WINDOW_FOREIGN)
{
children = tmp = private->children;
private->filters = NULL;
}
- if (private->drawable.window_type == GDK_WINDOW_FOREIGN)
+ if (private->window_type == GDK_WINDOW_FOREIGN)
{
if (our_destroy && (private->parent != NULL))
{
}
}
- if (private->drawable.colormap)
- gdk_colormap_unref (private->drawable.colormap);
+ if (private->colormap)
+ gdk_colormap_unref (private->colormap);
private->mapped = FALSE;
private->drawable.destroyed = TRUE;
g_error ("called gdk_window_destroy on a pixmap (use gdk_pixmap_unref)");
break;
}
+#endif
}
/* This function is called when the XWindow is really gone. */
-void
-gdk_window_destroy_notify (GdkWindow *window)
-{
- g_return_if_fail (window != NULL);
-
- if (!GDK_DRAWABLE_DESTROYED (window))
- {
- if (GDK_DRAWABLE_TYPE(window) != GDK_WINDOW_FOREIGN)
- g_warning ("GdkWindow %#x unexpectedly destroyed", GPOINTER_TO_UINT(window));
-
- _gdk_windowing_window_destroy (window, TRUE, TRUE);
- }
-
- gdk_drawable_unref (window);
-}
-
static gboolean all_parents_shown(GdkWindowPrivate *private)
{
while(private->mapped)
static void
send_map_events(GdkWindowPrivate *private, gboolean is_map)
{
- GdkEvent *event;
GList *l;
- GdkWindow *parent = private->parent;
+ GdkWindow *parent = (GdkWindow *)private->parent;
- if(!private->mapped || GDK_DRAWABLE_DESTROYED(private))
+ g_assert(is_map);
+
+ if(!private->mapped)
return;
if(is_map)
if(!parent)
parent = (GdkWindow *)private;
- if(((GDK_DRAWABLE_FBDATA(private)->abs_x > GDK_DRAWABLE_FBDATA(parent)->lim_x)
- || (GDK_DRAWABLE_FBDATA(private)->abs_y > GDK_DRAWABLE_FBDATA(parent)->lim_y)
- || (GDK_DRAWABLE_FBDATA(private)->lim_x < GDK_DRAWABLE_FBDATA(parent)->llim_x)
- || (GDK_DRAWABLE_FBDATA(private)->lim_y < GDK_DRAWABLE_FBDATA(parent)->llim_y)))
+ if(((GDK_DRAWABLE_IMPL_FBDATA(private)->abs_x > GDK_DRAWABLE_IMPL_FBDATA(parent)->lim_x)
+ || (GDK_DRAWABLE_IMPL_FBDATA(private)->abs_y > GDK_DRAWABLE_IMPL_FBDATA(parent)->lim_y)
+ || (GDK_DRAWABLE_IMPL_FBDATA(private)->lim_x < GDK_DRAWABLE_IMPL_FBDATA(parent)->llim_x)
+ || (GDK_DRAWABLE_IMPL_FBDATA(private)->lim_y < GDK_DRAWABLE_IMPL_FBDATA(parent)->llim_y)))
return;
if(is_map)
gdk_window_clear((GdkWindow *)private);
+#if 0
event = gdk_event_new();
event->expose.type = GDK_EXPOSE;
event->expose.window = gdk_window_ref((GdkWindow *)private);
- if(GDK_DRAWABLE_FBDATA(private)->abs_x > GDK_DRAWABLE_FBDATA(parent)->llim_x)
+ if(GDK_DRAWABLE_IMPL_FBDATA(private)->abs_x > GDK_DRAWABLE_IMPL_FBDATA(parent)->llim_x)
event->expose.area.x = 0;
else
- event->expose.area.x = GDK_DRAWABLE_FBDATA(parent)->llim_x - GDK_DRAWABLE_FBDATA(private)->abs_x;
+ event->expose.area.x = GDK_DRAWABLE_IMPL_FBDATA(parent)->llim_x - GDK_DRAWABLE_IMPL_FBDATA(private)->abs_x;
- if(GDK_DRAWABLE_FBDATA(private)->abs_y > GDK_DRAWABLE_FBDATA(parent)->llim_y)
+ if(GDK_DRAWABLE_IMPL_FBDATA(private)->abs_y > GDK_DRAWABLE_IMPL_FBDATA(parent)->llim_y)
event->expose.area.y = 0;
else
- event->expose.area.y = GDK_DRAWABLE_FBDATA(parent)->llim_y - GDK_DRAWABLE_FBDATA(private)->abs_y;
+ event->expose.area.y = GDK_DRAWABLE_IMPL_FBDATA(parent)->llim_y - GDK_DRAWABLE_IMPL_FBDATA(private)->abs_y;
- event->expose.area.width = MIN(private->drawable.width,
- GDK_DRAWABLE_FBDATA(private)->lim_x - GDK_DRAWABLE_FBDATA(private)->abs_x);
- event->expose.area.height = MIN(private->drawable.height,
- GDK_DRAWABLE_FBDATA(private)->lim_y - GDK_DRAWABLE_FBDATA(private)->abs_y);
+ event->expose.area.width = MIN(GDK_DRAWABLE_IMPL_FBDATA(private)->width,
+ GDK_DRAWABLE_IMPL_FBDATA(private)->lim_x - GDK_DRAWABLE_IMPL_FBDATA(private)->abs_x);
+ event->expose.area.height = MIN(GDK_DRAWABLE_IMPL_FBDATA(private)->height,
+ GDK_DRAWABLE_IMPL_FBDATA(private)->lim_y - GDK_DRAWABLE_IMPL_FBDATA(private)->abs_y);
if(event->expose.area.width > 0
&& event->expose.area.height > 0)
{
gdk_event_queue_append(event);
- for(l = private->children; l; l = l->next)
- send_map_events(l->data, is_map);
}
else
gdk_event_free(event);
-
+#endif
+ for(l = private->children; l; l = l->next)
+ send_map_events(l->data, is_map);
}
+/* Cut & paste versions of the stuff in gdkwindow.c, with the addition of clearing the newly exposed region. */
void
-gdk_fb_redraw_all(void)
+gdk_window_invalidate_region_clear(GdkWindow *window, GdkRegion *region)
{
- send_map_events((GdkWindowPrivate *)gdk_parent_root, FALSE);
+ int i;
+ GdkWindowPrivate *private = GDK_WINDOW_P(window);
+
+ if (private->input_only)
+ return;
+
+ if(private->bg_pixmap != GDK_NO_BG)
+ for(i = 0; i < region->numRects; i++)
+ gdk_window_clear_area(window,
+ region->rects[i].x1,
+ region->rects[i].y1,
+ region->rects[i].x2 - region->rects[i].x1,
+ region->rects[i].y2 - region->rects[i].y1);
+
+ gdk_window_invalidate_region(window, region, FALSE);
+
+ {
+ GList *tmp_list;
+ GdkRectangle child_rect;
+ GdkRegion *child_region;
+
+ tmp_list = private->children;
+ while (tmp_list)
+ {
+ GdkWindowObject *child = tmp_list->data;
+ tmp_list = tmp_list->next;
+
+ if (!child->input_only)
+ {
+ gint width, height;
+
+ gdk_drawable_get_size (GDK_DRAWABLE (child),
+ &width, &height);
+
+ child_rect.x = child->x;
+ child_rect.y = child->y;
+ child_rect.width = width;
+ child_rect.height = height;
+
+ child_region = gdk_region_rectangle (&child_rect);
+ gdk_region_intersect (child_region, region);
+
+ if (!gdk_region_empty (child_region))
+ {
+ gdk_region_offset (child_region, - child_rect.x, - child_rect.y);
+ gdk_window_invalidate_region_clear ((GdkWindow *)child, child_region);
+ }
+
+ gdk_region_destroy (child_region);
+ }
+ }
+ }
}
-static
-void gdk_fb_window_visibility_crossing(GdkWindow *window, gboolean is_show)
+void
+gdk_window_invalidate_rect_clear(GdkWindow *window, GdkRectangle *rect)
{
- gint winx, winy;
- GdkModifierType my_mask;
-
- gdk_input_ps2_get_mouseinfo(&winx, &winy, &my_mask);
+ GdkWindowPrivate *private = GDK_WINDOW_P(window);
- if(winx >= GDK_DRAWABLE_FBDATA(window)->llim_x
- && winx < GDK_DRAWABLE_FBDATA(window)->lim_x
- && winy >= GDK_DRAWABLE_FBDATA(window)->llim_y
- && winy < GDK_DRAWABLE_FBDATA(window)->lim_y && 0)
- {
- GdkWindow *oldwin, *newwin, *curwin;
- GdkEvent *event;
+ if (private->input_only)
+ return;
- curwin = gdk_window_get_pointer(NULL, NULL, NULL, NULL);
+ if(GDK_WINDOW_P(window)->bg_pixmap != GDK_NO_BG)
+ gdk_window_clear_area(window, rect->x, rect->y, rect->width, rect->height);
+ gdk_window_invalidate_rect(window, rect, FALSE);
+
+ {
+ GList *tmp_list;
+ GdkRectangle child_rect, new_rect;
+
+ tmp_list = private->children;
+ while (tmp_list)
+ {
+ GdkWindowObject *child = tmp_list->data;
+ tmp_list = tmp_list->next;
+
+ if (!child->input_only)
+ {
+ gint width, height;
+
+ width = GDK_DRAWABLE_IMPL_FBDATA(child)->width;
+ height = GDK_DRAWABLE_IMPL_FBDATA(child)->height;
+
+ child_rect.x = child->x;
+ child_rect.y = child->y;
+ child_rect.width = width;
+ child_rect.height = height;
+
+ if (gdk_rectangle_intersect (rect, &child_rect, &new_rect))
+ {
+ new_rect.x -= child_rect.x;
+ new_rect.y -= child_rect.y;
+
+ gdk_window_invalidate_rect_clear ((GdkWindow *)child, &new_rect);
+ }
+ }
+ }
+ }
- if(is_show)
- {
- /* Window is about to be shown */
- oldwin = curwin;
- newwin = window;
- }
- else
- {
- /* Window is about to be hidden */
- oldwin = window;
- newwin = curwin;
- }
- event = gdk_event_make(oldwin, GDK_LEAVE_NOTIFY, TRUE);
- if(event)
- {
- guint x_int, y_int;
- event->crossing.subwindow = gdk_window_ref(newwin);
- gdk_window_get_root_origin(oldwin, &x_int, &y_int);
- event->crossing.x = winx - x_int;
- event->crossing.y = winy - y_int;
- event->crossing.x_root = winx;
- event->crossing.y_root = winy;
- event->crossing.mode = GDK_CROSSING_NORMAL;
- event->crossing.detail = GDK_NOTIFY_UNKNOWN;
- event->crossing.focus = FALSE;
- event->crossing.state = my_mask;
- }
+}
- event = gdk_event_make(newwin, GDK_ENTER_NOTIFY, TRUE);
- if(event)
- {
- guint x_int, y_int;
- event->crossing.subwindow = gdk_window_ref(oldwin);
- gdk_window_get_root_origin(newwin, &x_int, &y_int);
- event->crossing.x = winx - x_int;
- event->crossing.y = winy - y_int;
- event->crossing.x_root = winx;
- event->crossing.y_root = winy;
- event->crossing.mode = GDK_CROSSING_NORMAL;
- event->crossing.detail = GDK_NOTIFY_UNKNOWN;
- event->crossing.focus = FALSE;
- event->crossing.state = my_mask;
- }
- }
+void
+gdk_fb_redraw_all(void)
+{
+ GdkRectangle r;
+ r.x = r.y = 0;
+ r.width = GDK_DRAWABLE_IMPL_FBDATA(gdk_parent_root)->width;
+ r.height = GDK_DRAWABLE_IMPL_FBDATA(gdk_parent_root)->height;
+ gdk_window_invalidate_rect(gdk_parent_root, &r, TRUE);
+ gdk_window_process_all_updates();
}
void
private = (GdkWindowPrivate*) window;
- if (!private->drawable.destroyed && !private->mapped)
+ if (!private->destroyed && !private->mapped)
{
private->mapped = TRUE;
if(all_parents_shown((GdkWindowPrivate *)private->parent))
{
+ GdkRectangle rect;
+
recompute_drawable((GdkDrawable *)window);
+
send_map_events(private, TRUE);
private->mapped = FALSE; /* a hack, ayup, to make gdk_window_get_pointer get the other window */
gdk_fb_window_visibility_crossing(window, TRUE);
private->mapped = TRUE;
- }
- }
-}
-
-static gboolean
-rects_overlap(GdkRectangle *r1, GdkRectangle *r2)
-{
- if(r1->x > (r2->x + r2->width))
- return FALSE;
- if(r2->x > (r1->x + r1->width))
- return FALSE;
- if(r1->y > (r2->y + r2->height))
- return FALSE;
- if(r2->y > (r1->y + r1->height))
- return FALSE;
-
- return TRUE;
-}
-
-static void
-gdk_window_on_hide(GdkWindow *window, GdkRectangle *in_rect, GdkWindow *ignore)
-{
- GdkEvent *event;
- GdkRectangle this_rect, test_rect;
-
- if(!GDK_WINDOW_P(window)->mapped || window == ignore || GDK_WINDOW_P(window)->input_only)
- return;
-
- this_rect.x = MAX(GDK_DRAWABLE_FBDATA(window)->llim_x - GDK_DRAWABLE_FBDATA(window)->abs_x, 0);
-
- this_rect.y = MAX(GDK_DRAWABLE_FBDATA(window)->llim_y - GDK_DRAWABLE_FBDATA(window)->abs_y, 0);
-
- this_rect.width = MIN(GDK_DRAWABLE_P(window)->width,
- GDK_DRAWABLE_FBDATA(window)->lim_x - GDK_DRAWABLE_FBDATA(window)->abs_x);
- this_rect.height = MIN(GDK_DRAWABLE_P(window)->height,
- GDK_DRAWABLE_FBDATA(window)->lim_y - GDK_DRAWABLE_FBDATA(window)->abs_y);
-
- test_rect = this_rect;
- test_rect.x += GDK_DRAWABLE_FBDATA(window)->abs_x;
- test_rect.y += GDK_DRAWABLE_FBDATA(window)->abs_y;
- if(this_rect.width > 0
- && this_rect.height > 0
- && rects_overlap(&test_rect, in_rect))
- {
- GList *l;
- event = gdk_event_make(window, GDK_EXPOSE, TRUE);
- if(event)
- event->expose.area = this_rect;
+ if(private->input_only)
+ return;
- for(l = GDK_WINDOW_P(window)->children; l; l = l->next)
- gdk_window_on_hide(l->data, in_rect, ignore);
+ rect.x = GDK_DRAWABLE_IMPL_FBDATA(window)->llim_x;
+ rect.y = GDK_DRAWABLE_IMPL_FBDATA(window)->llim_y;
+ rect.width = GDK_DRAWABLE_IMPL_FBDATA(window)->lim_x - rect.x;
+ rect.height = GDK_DRAWABLE_IMPL_FBDATA(window)->lim_y - rect.y;
+ gdk_window_invalidate_rect_clear(gdk_parent_root, &rect);
+ }
}
}
private = (GdkWindowPrivate*) window;
- if (!private->drawable.destroyed && private->mapped)
+ if (!private->destroyed && private->mapped)
{
GdkEvent *event;
GdkRectangle r;
+ gboolean do_hide;
event = gdk_event_make(window, GDK_UNMAP, TRUE);
- r.x = GDK_DRAWABLE_FBDATA(window)->llim_x;
- r.y = GDK_DRAWABLE_FBDATA(window)->llim_y;
- r.width = GDK_DRAWABLE_FBDATA(window)->lim_x - r.x;
- r.height = GDK_DRAWABLE_FBDATA(window)->lim_y - r.y;
+ r.x = GDK_DRAWABLE_IMPL_FBDATA(window)->llim_x;
+ r.y = GDK_DRAWABLE_IMPL_FBDATA(window)->llim_y;
+ r.width = GDK_DRAWABLE_IMPL_FBDATA(window)->lim_x - r.x;
+ r.height = GDK_DRAWABLE_IMPL_FBDATA(window)->lim_y - r.y;
private->mapped = FALSE;
- gdk_window_on_hide(private->parent, &r, NULL);
- if(private->parent == gdk_parent_root)
- gdk_fb_drawable_clear((GdkDrawable *)gdk_parent_root);
+ if(private->parent == GDK_WINDOW_P(gdk_parent_root))
+ gdk_fb_drawable_clear(gdk_parent_root);
if(all_parents_shown((GdkWindowPrivate *)private->parent))
gdk_fb_window_visibility_crossing(window, FALSE);
+
+ do_hide = gdk_fb_cursor_need_hide(&r);
+
+ if(do_hide)
+ gdk_fb_cursor_hide();
+ gdk_window_invalidate_rect_clear(gdk_parent_root, &r);
+ if(do_hide)
+ gdk_fb_cursor_unhide();
}
}
g_return_if_fail (GDK_IS_WINDOW (window));
gdk_window_move_resize (window, x, y,
- private->drawable.width, private->drawable.height);
+ GDK_DRAWABLE_IMPL_FBDATA(private)->width, GDK_DRAWABLE_IMPL_FBDATA(private)->height);
}
void
if(GDK_IS_WINDOW(drawable))
{
GdkWindowPrivate *private = GDK_WINDOW_P(drawable);
+ int x, y;
if(!private->mapped)
return;
- GDK_DRAWABLE_FBDATA(private)->abs_x = parent_x + private->x;
- GDK_DRAWABLE_FBDATA(private)->abs_y = parent_y + private->y;
- GDK_DRAWABLE_FBDATA(private)->llim_x = MIN(MAX(parent_llim_x, GDK_DRAWABLE_FBDATA(private)->abs_x),
- parent_lim_x);
- GDK_DRAWABLE_FBDATA(private)->llim_y = MIN(MAX(parent_llim_y, GDK_DRAWABLE_FBDATA(private)->abs_y),
- parent_lim_y);
- GDK_DRAWABLE_FBDATA(private)->lim_x = MAX(MIN(parent_lim_x, GDK_DRAWABLE_FBDATA(private)->abs_x + GDK_DRAWABLE_P(private)->width),
- GDK_DRAWABLE_FBDATA(private)->llim_x);
- GDK_DRAWABLE_FBDATA(private)->lim_y = MAX(MIN(parent_lim_y,
- GDK_DRAWABLE_FBDATA(private)->abs_y + GDK_DRAWABLE_P(private)->height),
- GDK_DRAWABLE_FBDATA(private)->llim_y);
-
- g_assert(GDK_DRAWABLE_FBDATA(private)->llim_x <= GDK_DRAWABLE_FBDATA(private)->lim_x);
- g_assert(GDK_DRAWABLE_FBDATA(private)->llim_y <= GDK_DRAWABLE_FBDATA(private)->lim_y);
+
+ GDK_DRAWABLE_IMPL_FBDATA(private)->abs_x = parent_x + private->x;
+ GDK_DRAWABLE_IMPL_FBDATA(private)->abs_y = parent_y + private->y;
+ x = MAX(parent_llim_x, GDK_DRAWABLE_IMPL_FBDATA(private)->abs_x);
+ x = MIN(x, parent_lim_x);
+ GDK_DRAWABLE_IMPL_FBDATA(private)->llim_x = x;
+ y = MAX(parent_llim_y, GDK_DRAWABLE_IMPL_FBDATA(private)->abs_y);
+ y = MIN(y, parent_lim_y);
+ GDK_DRAWABLE_IMPL_FBDATA(private)->llim_y = y;
+ x = MIN(parent_lim_x,
+ GDK_DRAWABLE_IMPL_FBDATA(private)->abs_x + GDK_DRAWABLE_IMPL_FBDATA(private)->width);
+ x = MAX(x, GDK_DRAWABLE_IMPL_FBDATA(private)->llim_x);
+ GDK_DRAWABLE_IMPL_FBDATA(private)->lim_x = x;
+ y = MIN(parent_lim_y,
+ GDK_DRAWABLE_IMPL_FBDATA(private)->abs_y + GDK_DRAWABLE_IMPL_FBDATA(private)->height);
+ y = MAX(y, GDK_DRAWABLE_IMPL_FBDATA(private)->llim_y);
+ GDK_DRAWABLE_IMPL_FBDATA(private)->lim_y = y;
+
+ g_assert(GDK_DRAWABLE_IMPL_FBDATA(private)->llim_x <= GDK_DRAWABLE_IMPL_FBDATA(private)->lim_x);
+ g_assert(GDK_DRAWABLE_IMPL_FBDATA(private)->llim_y <= GDK_DRAWABLE_IMPL_FBDATA(private)->lim_y);
for(l = private->children; l; l = l->next)
- recompute_abs_positions(l->data, GDK_DRAWABLE_FBDATA(private)->abs_x, GDK_DRAWABLE_FBDATA(private)->abs_y,
- GDK_DRAWABLE_FBDATA(private)->llim_x, GDK_DRAWABLE_FBDATA(private)->llim_y,
- GDK_DRAWABLE_FBDATA(private)->lim_x, GDK_DRAWABLE_FBDATA(private)->lim_y);
+ recompute_abs_positions(l->data, GDK_DRAWABLE_IMPL_FBDATA(private)->abs_x, GDK_DRAWABLE_IMPL_FBDATA(private)->abs_y,
+ GDK_DRAWABLE_IMPL_FBDATA(private)->llim_x, GDK_DRAWABLE_IMPL_FBDATA(private)->llim_y,
+ GDK_DRAWABLE_IMPL_FBDATA(private)->lim_x, GDK_DRAWABLE_IMPL_FBDATA(private)->lim_y);
}
else
{
- GDK_DRAWABLE_FBDATA(drawable)->abs_x = 0;
- GDK_DRAWABLE_FBDATA(drawable)->abs_y = 0;
- GDK_DRAWABLE_FBDATA(drawable)->llim_x = 0;
- GDK_DRAWABLE_FBDATA(drawable)->llim_y = 0;
- GDK_DRAWABLE_FBDATA(drawable)->lim_x = GDK_DRAWABLE_P(drawable)->width;
- GDK_DRAWABLE_FBDATA(drawable)->lim_y = GDK_DRAWABLE_P(drawable)->height;
+ GDK_DRAWABLE_IMPL_FBDATA(drawable)->abs_x = 0;
+ GDK_DRAWABLE_IMPL_FBDATA(drawable)->abs_y = 0;
+ GDK_DRAWABLE_IMPL_FBDATA(drawable)->llim_x = 0;
+ GDK_DRAWABLE_IMPL_FBDATA(drawable)->llim_y = 0;
+ GDK_DRAWABLE_IMPL_FBDATA(drawable)->lim_x = GDK_DRAWABLE_IMPL_FBDATA(drawable)->width;
+ GDK_DRAWABLE_IMPL_FBDATA(drawable)->lim_y = GDK_DRAWABLE_IMPL_FBDATA(drawable)->height;
}
}
GdkWindowPrivate *private = GDK_WINDOW_P(drawable);
GdkWindow *parent;
- parent = private->parent;
+ parent = (GdkWindow *)private->parent;
if(!parent)
parent = gdk_parent_root;
- recompute_abs_positions(drawable, GDK_DRAWABLE_FBDATA(parent)->abs_x,
- GDK_DRAWABLE_FBDATA(parent)->abs_y,
- GDK_DRAWABLE_FBDATA(parent)->llim_x,
- GDK_DRAWABLE_FBDATA(parent)->llim_y,
- GDK_DRAWABLE_FBDATA(parent)->lim_x,
- GDK_DRAWABLE_FBDATA(parent)->lim_y);
+ recompute_abs_positions(drawable, GDK_DRAWABLE_IMPL_FBDATA(parent)->abs_x,
+ GDK_DRAWABLE_IMPL_FBDATA(parent)->abs_y,
+ GDK_DRAWABLE_IMPL_FBDATA(parent)->llim_x,
+ GDK_DRAWABLE_IMPL_FBDATA(parent)->llim_y,
+ GDK_DRAWABLE_IMPL_FBDATA(parent)->lim_x,
+ GDK_DRAWABLE_IMPL_FBDATA(parent)->lim_y);
}
else
recompute_abs_positions(drawable, 0, 0, 0, 0, INT_MAX, INT_MAX);
}
void
-gdk_window_move_resize (GdkWindow *window,
- gint x,
- gint y,
- gint width,
- gint height)
+gdk_fb_window_move_resize (GdkWindow *window,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ gboolean send_expose_events)
{
GdkWindowPrivate *private;
-
+ gint dx, dy, dw, dh;
+
g_return_if_fail (window != NULL);
g_return_if_fail (GDK_IS_WINDOW (window));
width = 1;
if (height < 1)
height = 1;
-
+
private = (GdkWindowPrivate*) window;
- if (!GDK_DRAWABLE_DESTROYED (window))
+ if (!private->destroyed)
{
+ GdkRegion *old_region;
+ GdkRectangle old_rect;
+
+ if(private->input_only)
+ send_expose_events = FALSE;
+
+ if(private->mapped && send_expose_events)
+ {
+ old_region = gdk_fb_clip_region(GDK_DRAWABLE_IMPL(window), NULL, TRUE, FALSE);
+
+ old_rect.x = GDK_DRAWABLE_IMPL_FBDATA(window)->llim_x;
+ old_rect.y = GDK_DRAWABLE_IMPL_FBDATA(window)->llim_y;
+ old_rect.width = GDK_DRAWABLE_IMPL_FBDATA(window)->lim_x - old_rect.x;
+ old_rect.height = GDK_DRAWABLE_IMPL_FBDATA(window)->lim_y - old_rect.y;
+ }
+
+ dx = x - private->x;
+ dy = y - private->y;
+ dw = width - GDK_DRAWABLE_IMPL_FBDATA(private)->width;
+ dh = height - GDK_DRAWABLE_IMPL_FBDATA(private)->height;
+
private->x = x;
private->y = y;
- GDK_DRAWABLE_P(private)->width = width;
- GDK_DRAWABLE_P(private)->height = height;
+ GDK_DRAWABLE_IMPL_FBDATA(private)->width = width;
+ GDK_DRAWABLE_IMPL_FBDATA(private)->height = height;
if(private->mapped)
{
- GdkRectangle r;
+ recompute_drawable((GdkDrawable *)window);
- r.x = GDK_DRAWABLE_FBDATA(window)->llim_x;
- r.y = GDK_DRAWABLE_FBDATA(window)->llim_y;
- r.width = GDK_DRAWABLE_FBDATA(window)->lim_x - r.x;
- r.height = GDK_DRAWABLE_FBDATA(window)->lim_y - r.y;
+ if(send_expose_events)
+ {
+ GdkRectangle new_rect;
+ GdkRegion *new_region, *region;
+ int i;
+ gboolean handle_cursor = FALSE;
- recompute_drawable((GdkDrawable *)window);
- send_map_events(private, FALSE);
+ new_region = gdk_fb_clip_region(GDK_DRAWABLE_IMPL(window), NULL, TRUE, FALSE);
- gdk_window_on_hide(private->parent, &r, window);
+ new_rect.x = GDK_DRAWABLE_IMPL_FBDATA(window)->llim_x;
+ new_rect.y = GDK_DRAWABLE_IMPL_FBDATA(window)->llim_y;
+ new_rect.width = GDK_DRAWABLE_IMPL_FBDATA(window)->lim_x - new_rect.x;
+ new_rect.height = GDK_DRAWABLE_IMPL_FBDATA(window)->lim_y - new_rect.y;
+
+ region = gdk_region_copy(old_region);
+ gdk_region_offset(region, dx, dy);
+ gdk_region_intersect(region, new_region);
+
+ if(region->numRects)
+ {
+ GdkFBDrawingContext fbdc;
+ GdkRectangle cursor_rect;
+
+ gdk_fb_get_cursor_rect(&cursor_rect);
+
+ if(gdk_fb_cursor_region_need_hide(region))
+ {
+ gdk_fb_cursor_hide();
+ handle_cursor = TRUE;
+ }
+
+ gdk_fb_drawing_context_init(&fbdc, GDK_DRAWABLE_IMPL(gdk_parent_root), NULL, FALSE, FALSE);
+ for(i = 0; i < region->numRects; i++)
+ {
+ gdk_fb_draw_drawable_3(GDK_DRAWABLE_IMPL(gdk_parent_root), NULL, GDK_DRAWABLE_IMPL(gdk_parent_root),
+ &fbdc,
+ (region->rects[i].x1 - dx),
+ (region->rects[i].y1 - dy),
+ (region->rects[i].x1),
+ (region->rects[i].y1),
+ (region->rects[i].x2 - region->rects[i].x1),
+ (region->rects[i].y2 - region->rects[i].y1));
+ }
+ gdk_fb_drawing_context_finalize(&fbdc);
+ }
+
+ gdk_region_union(new_region, old_region);
+ gdk_region_subtract(new_region, region);
+ gdk_region_destroy(region);
+ gdk_window_invalidate_region_clear(gdk_parent_root, new_region);
+ if(handle_cursor)
+ gdk_fb_cursor_unhide();
+
+ gdk_region_destroy(old_region);
+ gdk_region_destroy(new_region);
+ }
}
}
}
+void
+gdk_window_move_resize (GdkWindow *window,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ gdk_fb_window_move_resize(window, x, y, width, height, TRUE);
+}
+
void
gdk_window_reparent (GdkWindow *window,
GdkWindow *new_parent,
old_parent_private = (GdkWindowPrivate*)window_private->parent;
parent_private = (GdkWindowPrivate*) new_parent;
- g_assert(window_private->drawable.colormap);
+ g_assert(GDK_DRAWABLE_IMPL_FBDATA(window_private)->colormap);
- window_private->parent = new_parent;
+ window_private->parent = (GdkWindowPrivate *)new_parent;
if (old_parent_private)
old_parent_private->children = g_list_remove (old_parent_private->children, window);
parent_private->children = g_list_prepend (parent_private->children, window);
if(window_private->mapped)
- recompute_drawable((GdkDrawable *)window);
+ {
+ GdkRectangle r;
+ GdkRegion *region;
+
+ r.x = GDK_DRAWABLE_IMPL_FBDATA(window)->llim_x;
+ r.y = GDK_DRAWABLE_IMPL_FBDATA(window)->llim_y;
+ r.width = GDK_DRAWABLE_IMPL_FBDATA(window)->lim_x - r.x;
+ r.height = GDK_DRAWABLE_IMPL_FBDATA(window)->lim_y - r.y;
+ region = gdk_region_rectangle(&r);
+
+ recompute_drawable((GdkDrawable *)window);
+ r.x = GDK_DRAWABLE_IMPL_FBDATA(window)->llim_x;
+ r.y = GDK_DRAWABLE_IMPL_FBDATA(window)->llim_y;
+ r.width = GDK_DRAWABLE_IMPL_FBDATA(window)->lim_x - r.x;
+ r.height = GDK_DRAWABLE_IMPL_FBDATA(window)->lim_y - r.y;
+ gdk_region_union_with_rect(region, &r);
+
+ gdk_window_invalidate_region_clear(gdk_parent_root, region);
+ gdk_region_destroy(region);
+ }
}
GdkPixmap *bgpm;
GdkWindow *relto;
- g_return_if_fail (window != NULL);
- g_return_if_fail (GDK_IS_WINDOW (window));
-
if(GDK_WINDOW_P(window)->input_only)
return;
bgpm = GDK_WINDOW_P(window)->bg_pixmap;
- for(relto = window; bgpm == GDK_PARENT_RELATIVE_BG && relto; relto = GDK_WINDOW_P(relto)->parent)
+
+#if 0
+ for(relto = window; bgpm == GDK_PARENT_RELATIVE_BG && relto; relto = (GdkWindow *)GDK_WINDOW_P(relto)->parent)
bgpm = GDK_WINDOW_P(relto)->bg_pixmap;
+#endif
if(bgpm && bgpm != GDK_NO_BG)
{
int curx, cury;
int xtrans, ytrans;
int xstep, ystep;
+ GdkFBDrawingContext fbdc;
- return; /* Don't bother doing this - gtk+ will do it itself using GC tiles */
+ return; /* Don't bother doing this - gtk+ will do it itself using GC tiles. If removing this line,
+ then also remove the #if 0 stuff */
- xtrans = GDK_DRAWABLE_FBDATA(relto)->abs_x - GDK_DRAWABLE_FBDATA(window)->abs_x;
- ytrans = GDK_DRAWABLE_FBDATA(relto)->abs_y - GDK_DRAWABLE_FBDATA(window)->abs_y;
+ gdk_fb_drawing_context_init(&fbdc, window, NULL, FALSE, TRUE);
+
+ xtrans = GDK_DRAWABLE_IMPL_FBDATA(relto)->abs_x - GDK_DRAWABLE_IMPL_FBDATA(window)->abs_x;
+ ytrans = GDK_DRAWABLE_IMPL_FBDATA(relto)->abs_y - GDK_DRAWABLE_IMPL_FBDATA(window)->abs_y;
for(cury = y - ytrans; cury < (y - ytrans + height); cury += ystep)
{
for(curx = x - xtrans; curx < (x - xtrans + width); curx += xstep)
{
- int draww = curx % GDK_DRAWABLE_P(bgpm)->width;
- xstep = GDK_DRAWABLE_P(bgpm)->width - draww;
+ int draww = curx % GDK_DRAWABLE_IMPL_FBDATA(bgpm)->width;
+ xstep = GDK_DRAWABLE_IMPL_FBDATA(bgpm)->width - draww;
- gdk_fb_draw_drawable_2(window, NULL, bgpm,
+ gdk_fb_draw_drawable_3(GDK_DRAWABLE_IMPL(window), NULL, GDK_DRAWABLE_IMPL(bgpm),
+ &fbdc,
draww, drawh, curx + xtrans, cury + ytrans,
- xstep, ystep, FALSE, TRUE);
+ xstep, ystep);
}
}
+
+ gdk_fb_drawing_context_finalize(&fbdc);
}
else if(!bgpm)
- gdk_fb_draw_rectangle(window, NULL, TRUE, x, y, width, height);
+ gdk_fb_draw_rectangle(GDK_DRAWABLE_IMPL(window), NULL, TRUE, x, y, width, height);
}
/* What's the diff? */
static gint
compare_window_levels(gconstpointer a, gconstpointer b)
{
- return (GDK_WINDOW_FBDATA(b)->level - GDK_WINDOW_FBDATA(a)->level);
+ return (GDK_WINDOW_IMPL_FBDATA(b)->level - GDK_WINDOW_IMPL_FBDATA(a)->level);
}
/* Child list is sorted bottom-to-top */
/* Now the fun part - redraw */
if(GDK_WINDOW_P(win)->parent)
- send_map_events(private, FALSE);
+ {
+ gdk_window_invalidate_rect(win, NULL, TRUE);
+ }
}
void
g_return_if_fail (window != NULL);
g_return_if_fail (GDK_IS_WINDOW (window));
- GDK_WINDOW_FBDATA(window)->level++;
+ GDK_WINDOW_IMPL_FBDATA(window)->level++;
if(GDK_WINDOW_P(window)->parent)
- gdk_window_resort_children(GDK_WINDOW_P(window)->parent);
+ gdk_window_resort_children((GdkWindow *)GDK_WINDOW_P(window)->parent);
}
void
g_return_if_fail (window != NULL);
g_return_if_fail (GDK_IS_WINDOW (window));
- GDK_WINDOW_FBDATA(window)->level--;
+ GDK_WINDOW_IMPL_FBDATA(window)->level--;
if(GDK_WINDOW_P(window)->parent)
- gdk_window_resort_children(GDK_WINDOW_P(window)->parent);
+ gdk_window_resort_children((GdkWindow *)GDK_WINDOW_P(window)->parent);
}
void
gdk_window_set_transient_for (GdkWindow *window,
GdkWindow *parent)
{
- GDK_WINDOW_FBDATA(window)->level = GDK_WINDOW_FBDATA(parent)->level + 1;
+ GDK_WINDOW_IMPL_FBDATA(window)->level = GDK_WINDOW_IMPL_FBDATA(parent)->level + 1;
}
void
gdk_window_set_cursor (GdkWindow *window,
GdkCursor *cursor)
{
- GdkCursor *old_cursor = GDK_WINDOW_FBDATA(window)->cursor;
+ GdkCursor *old_cursor = GDK_WINDOW_IMPL_FBDATA(window)->cursor;
+ GdkRectangle window_reg;
- GDK_WINDOW_FBDATA(window)->cursor = cursor?gdk_cursor_ref(cursor):NULL;
+ GDK_WINDOW_IMPL_FBDATA(window)->cursor = cursor?gdk_cursor_ref(cursor):NULL;
if(old_cursor)
gdk_cursor_unref(old_cursor);
+
+ window_reg.x = GDK_DRAWABLE_IMPL_FBDATA(window)->llim_x;
+ window_reg.y = GDK_DRAWABLE_IMPL_FBDATA(window)->llim_y;
+ window_reg.width = GDK_DRAWABLE_IMPL_FBDATA(window)->lim_x - window_reg.x;
+ window_reg.height = GDK_DRAWABLE_IMPL_FBDATA(window)->lim_y - window_reg.y;
+ if(gdk_fb_cursor_need_hide(&window_reg))
+ {
+ gdk_fb_cursor_reset();
+ }
}
void
if (!window)
window = gdk_parent_root;
- if (!GDK_DRAWABLE_DESTROYED (window))
+ if (!private->destroyed)
{
if (x)
if (y)
*y = private->y;
if (width)
- *width = GDK_DRAWABLE_P(window)->width;
+ *width = GDK_DRAWABLE_IMPL_FBDATA(window)->width;
if (height)
- *height = GDK_DRAWABLE_P(window)->height;
+ *height = GDK_DRAWABLE_IMPL_FBDATA(window)->height;
if (depth)
*depth = gdk_display->modeinfo.bits_per_pixel;
}
g_return_val_if_fail (window != NULL, 0);
if (x)
- *x = GDK_DRAWABLE_FBDATA(window)->abs_x;
+ *x = GDK_DRAWABLE_IMPL_FBDATA(window)->abs_x;
if (y)
- *y = GDK_DRAWABLE_FBDATA(window)->abs_y;
+ *y = GDK_DRAWABLE_IMPL_FBDATA(window)->abs_y;
return TRUE;
}
g_return_val_if_fail (window != NULL, 0);
- if (!GDK_DRAWABLE_DESTROYED (window))
+ if (!GDK_WINDOW_DESTROYED (window))
{
- tx = GDK_DRAWABLE_FBDATA(window)->abs_x;
- ty = GDK_DRAWABLE_FBDATA(window)->abs_y;
+ tx = GDK_DRAWABLE_IMPL_FBDATA(window)->abs_x;
+ ty = GDK_DRAWABLE_IMPL_FBDATA(window)->abs_y;
return_val = TRUE;
}
return_val = NULL;
- if((winx >= 0) && (winx < GDK_DRAWABLE_P(window)->width)
- && (winy >= 0) && (winy < GDK_DRAWABLE_P(window)->height))
+ if((winx >= 0) && (winx < GDK_DRAWABLE_IMPL_FBDATA(window)->width)
+ && (winy >= 0) && (winy < GDK_DRAWABLE_IMPL_FBDATA(window)->height))
{
GdkWindowPrivate *private;
GdkWindowPrivate *sub;
continue;
if(subx >= sub->x
- && (subx < (GDK_DRAWABLE_P(sub)->width + sub->x))
+ && (subx < (GDK_DRAWABLE_IMPL_FBDATA(sub)->width + sub->x))
&& (suby >= sub->y)
- && (suby < (GDK_DRAWABLE_P(sub)->height + sub->y)))
+ && (suby < (GDK_DRAWABLE_IMPL_FBDATA(sub)->height + sub->y)))
{
subx -= sub->x;
suby -= sub->y;
return retval;
}
-GList*
-gdk_window_get_children (GdkWindow *window)
-{
- GList *children;
-
- g_return_val_if_fail (window != NULL, NULL);
- g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
-
- if (GDK_DRAWABLE_DESTROYED (window))
- return NULL;
-
- children = NULL;
-
- return ((GdkWindowPrivate *)window)->children; /* Need to copy this list? */
-}
-
GdkEventMask
gdk_window_get_events (GdkWindow *window)
{
g_return_val_if_fail (window != NULL, 0);
g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
- if (GDK_DRAWABLE_DESTROYED (window))
+ if (GDK_WINDOW_DESTROYED (window))
return 0;
else
- return GDK_WINDOW_FBDATA(window)->event_mask;
+ return GDK_WINDOW_IMPL_FBDATA(window)->event_mask;
}
void
g_return_if_fail (window != NULL);
g_return_if_fail (GDK_IS_WINDOW (window));
- if (!GDK_DRAWABLE_DESTROYED (window))
- GDK_WINDOW_FBDATA(window)->event_mask = event_mask;
+ if (!GDK_WINDOW_DESTROYED (window))
+ GDK_WINDOW_IMPL_FBDATA(window)->event_mask = event_mask;
}
void
/* compute pixmap size; limit it to size of drawable */
xOrg = MAX(xMin, 0);
yOrg = MAX(yMin, 0);
- pixmapWidth = MIN(xMax, GDK_DRAWABLE_P(pDraw)->width) - xOrg;
- pixmapHeight = MIN(yMax, GDK_DRAWABLE_P(pDraw)->height) - yOrg;
+ pixmapWidth = MIN(xMax, GDK_DRAWABLE_FBDATA(pDraw)->width) - xOrg;
+ pixmapHeight = MIN(yMax, GDK_DRAWABLE_FBDATA(pDraw)->height) - yOrg;
/* if nothing left, return */
if ( (pixmapWidth <= 0) || (pixmapHeight <= 0) ) return;
}
static void
-miLineJoin (pDrawable, pGC, pixel, spanData, pLeft, pRight)
- GdkDrawable* pDrawable;
- GdkGC* pGC;
- GdkColor *pixel;
- SpanDataPtr spanData;
- register LineFacePtr pLeft, pRight;
+miLineJoin (GdkDrawable *pDrawable, GdkGC *pGC, GdkColor *pixel, SpanDataPtr spanData, LineFacePtr pLeft, LineFacePtr pRight)
{
double mx, my;
double denom = 0.0;
else if (GDK_GC_FBDATA(pGC)->values.cap_style == GDK_CAP_ROUND)
{
if (GDK_GC_FBDATA(pGC)->values.line_width == 1 && !spanData)
- miLineOnePoint (pDrawable, pGC, pixel, spanData, x1, y1);
+ miLineOnePoint (pDrawable, pGC, &pixel, spanData, x1, y1);
else
- miLineArc (pDrawable, pGC, pixel, spanData,
+ miLineArc (pDrawable, pGC, &pixel, spanData,
&leftFace, (LineFacePtr) NULL,
(double)0.0, (double)0.0,
TRUE);
}
else
{
- miLineJoin (pDrawable, pGC, pixel, spanData, &leftFace,
+ miLineJoin (pDrawable, pGC, &pixel, spanData, &leftFace,
&prevRightFace);
}
prevRightFace = rightFace;
if (npt == 1 && somethingDrawn)
{
if (selfJoin)
- miLineJoin (pDrawable, pGC, pixel, spanData, &firstFace,
+ miLineJoin (pDrawable, pGC, &pixel, spanData, &firstFace,
&rightFace);
else if (GDK_GC_FBDATA(pGC)->values.cap_style == GDK_CAP_ROUND)
{
if (GDK_GC_FBDATA(pGC)->values.line_width == 1 && !spanData)
- miLineOnePoint (pDrawable, pGC, pixel, spanData, x2, y2);
+ miLineOnePoint (pDrawable, pGC, &pixel, spanData, x2, y2);
else
- miLineArc (pDrawable, pGC, pixel, spanData,
+ miLineArc (pDrawable, pGC, &pixel, spanData,
(LineFacePtr) NULL, &rightFace,
(double)0.0, (double)0.0,
TRUE);
}
else
{
- miLineJoin (pDrawable, pGC, pixel, spanData, &leftFace,
+ miLineJoin (pDrawable, pGC, &pixel, spanData, &leftFace,
&prevRightFace);
}
}
pixel = endIsFg ? GDK_GC_FBDATA(pGC)->values.foreground : GDK_GC_FBDATA(pGC)->values.background;
if (selfJoin && (GDK_GC_FBDATA(pGC)->values.line_style == GDK_LINE_DOUBLE_DASH || firstIsFg))
{
- miLineJoin (pDrawable, pGC, pixel, spanData, &firstFace,
+ miLineJoin (pDrawable, pGC, &pixel, spanData, &firstFace,
&rightFace);
}
else
{
if (GDK_GC_FBDATA(pGC)->values.cap_style == GDK_CAP_ROUND)
- miLineArc (pDrawable, pGC, pixel, spanData,
+ miLineArc (pDrawable, pGC, &pixel, spanData,
(LineFacePtr) NULL, &rightFace,
(double)0.0, (double)0.0, TRUE);
}
xleft = 0;
ytop = 0;
- xright = GDK_DRAWABLE_P(pDraw)->width - 1;
- ybottom = GDK_DRAWABLE_P(pDraw)->height - 1;
+ xright = GDK_DRAWABLE_FBDATA(pDraw)->width - 1;
+ ybottom = GDK_DRAWABLE_FBDATA(pDraw)->height - 1;
/* it doesn't matter whether we're in drawable or screen coordinates,
* FillSpans simply cannot take starting coordinates outside of the
PangoGlyph
pango_fb_get_unknown_glyph(PangoFont *font)
{
- return '*';
+ return FT_Get_Char_Index(PANGO_FB_FONT(font)->ftf, '~');
}
typedef struct _CharRange CharRange;
char *outptr = &outbuf;
size_t outbytesleft = 1;
- inbytesleft = g_utf8_next_char (input) - input;
+ inbytesleft = g_utf8_next_char(input) - input;
cd = find_converter (cache, charset);
char *outptr = outbuf;
size_t outbytesleft = 2;
- inbytesleft = g_utf8_next_char (input) - input;
+ inbytesleft = g_utf8_next_char(input) - input;
cd = find_converter (cache, charset);
char buf[6];
const char *input;
- wc = g_utf8_get_char (p);
+ wc = g_utf8_get_char(p);
input = p;
if (analysis->level % 2)
set_glyph (font, glyphs, i, p - text, pango_fb_get_unknown_glyph (font));
}
- p = g_utf8_next_char (p);
+ p = g_utf8_next_char(p);
}
/* Simple bidi support... may have separate modules later */
projects / gtk4.git / commitdiff